Referência do desenvolvedor de C# do Azure FunctionsAzure Functions C# developer reference

Este artigo é uma introdução ao desenvolvimento do Azure Functions usando o script C# em biblioteca de classes .NET.This article is an introduction to developing Azure Functions by using C# in .NET class libraries.

O Azure Functions oferece suporte às linguagens de programação C# e script C#.Azure Functions supports C# and C# script programming languages. Se estiver procurando diretrizes sobre como usar C# no portal do Azure, consulte Referência do desenvolvedor de script C# (.csx).If you're looking for guidance on using C# in the Azure portal, see C# script (.csx) developer reference.

Este artigo pressupõe que você tenha completado as seguintes etapas:This article assumes that you've already read the following articles:

Versões com suporteSupported versions

As versões do tempo de execução do Functions funcionam com versões específicas do .NET.Versions of the Functions runtime work with specific versions of .NET. A tabela a seguir mostra o nível mais alto de .NET Core e .NET Framework e .NET Core que podem ser usados com uma versão específica de funções em seu projeto.The following table shows the highest level of .NET Core and .NET Framework and .NET Core that can be used with a specific version of Functions in your project.

Versão de tempo de execução do FunctionsFunctions runtime version Versão máxima do .NETMax .NET version
Funções 3. xFunctions 3.x .NET Core 3,1.NET Core 3.1
Funções 2.xFunctions 2.x .NET Core 2.2.NET Core 2.2
Funções 1.xFunctions 1.x .NET framework 4.6.NET Framework 4.6

Para saber mais, consulte visão geral das versões do Azure Functions RuntimeTo learn more, see Azure Functions runtime versions overview

Projeto de biblioteca de classes de funçõesFunctions class library project

No Visual Studio, o modelo de projeto do Azure Functions cria um projeto de biblioteca de classes do C# que contém os seguintes arquivos:In Visual Studio, the Azure Functions project template creates a C# class library project that contains the following files:

Quando você cria o projeto, uma estrutura de pastas parecida com o exemplo a seguir é gerada no diretório de saída da compilação:When you build the project, a folder structure that looks like the following example is generated in the build output directory:

<framework.version>
 | - bin
 | - MyFirstFunction
 | | - function.json
 | - MySecondFunction
 | | - function.json
 | - host.json

Esse é o diretório implantado no aplicativo de funções no Azure.This directory is what gets deployed to your function app in Azure. As extensões de associação necessárias na versão 2.x do runtime das Funções são adicionadas ao projeto como pacotes do NuGet.The binding extensions required in version 2.x of the Functions runtime are added to the project as NuGet packages.

Importante

O processo de compilação cria um arquivo function.json para cada função.The build process creates a function.json file for each function. Esse arquivo function.json não deve ser editado diretamente.This function.json file is not meant to be edited directly. Você não pode alterar a configuração de associação ou desabilitar a função por meio da edição desse arquivo.You can't change binding configuration or disable the function by editing this file. Para aprender como desabilitar uma função, consulte Como desabilitar funções.To learn how to disable a function, see How to disable functions.

Métodos reconhecidos como funçõesMethods recognized as functions

Em uma biblioteca de classe, uma função é um método estático com um FunctionName e um atributo de gatilho, conforme mostrado no exemplo a seguir:In a class library, a function is a static method with a FunctionName and a trigger attribute, as shown in the following example:

public static class SimpleExample
{
    [FunctionName("QueueTrigger")]
    public static void Run(
        [QueueTrigger("myqueue-items")] string myQueueItem, 
        ILogger log)
    {
        log.LogInformation($"C# function processed: {myQueueItem}");
    }
} 

O atributo FunctionName marca o método como um ponto de entrada da função.The FunctionName attribute marks the method as a function entry point. O nome deve ser exclusivo em um projeto, começar com uma letra e conter apenas letras, números, _e -, até 127 caracteres de comprimento.The name must be unique within a project, start with a letter and only contain letters, numbers, _, and -, up to 127 characters in length. Modelos de projeto geralmente criam um método chamado Run, mas o nome do método pode ser qualquer nome de método C# válido.Project templates often create a method named Run, but the method name can be any valid C# method name.

O atributo de gatilho especifica o tipo de gatilho e associa dados de entrada a um parâmetro de método.The trigger attribute specifies the trigger type and binds input data to a method parameter. A função de exemplo é disparada por uma mensagem de fila, a qual é transmitida para o método no parâmetro myQueueItem.The example function is triggered by a queue message, and the queue message is passed to the method in the myQueueItem parameter.

Parâmetros de assinatura do métodoMethod signature parameters

A assinatura do método pode conter parâmetros diferentes daquela usada com o atributo de gatilho.The method signature may contain parameters other than the one used with the trigger attribute. Aqui estão alguns dos parâmetros adicionais que você pode incluir:Here are some of the additional parameters that you can include:

Não importa a ordem dos parâmetros na assinatura de função.The order of parameters in the function signature does not matter. Por exemplo, você pode inserir os parâmetros de gatilho antes ou depois de outras associações e inserir o parâmetro do agente antes ou depois dos parâmetros de gatilho ou associação.For example, you can put trigger parameters before or after other bindings, and you can put the logger parameter before or after trigger or binding parameters.

Exemplo de associação de saídaOutput binding example

O exemplo a seguir modifica o anterior por adicionar uma associação de fila de saída.The following example modifies the preceding one by adding an output queue binding. A função grava a mensagem da fila que aciona a função para uma nova mensagem de fila em uma fila diferente.The function writes the queue message that triggers the function to a new queue message in a different queue.

public static class SimpleExampleWithOutput
{
    [FunctionName("CopyQueueMessage")]
    public static void Run(
        [QueueTrigger("myqueue-items-source")] string myQueueItem, 
        [Queue("myqueue-items-destination")] out string myQueueItemCopy,
        ILogger log)
    {
        log.LogInformation($"CopyQueueMessage function processed: {myQueueItem}");
        myQueueItemCopy = myQueueItem;
    }
}

Os artigos de referência de associação (Filas de armazenamento, por exemplo) explicam quais tipos de parâmetro você pode usar com os atributos de associação de gatilho, entrada ou saída.The binding reference articles (Storage queues, for example) explain which parameter types you can use with trigger, input, or output binding attributes.

Exemplo de expressões de associaçãoBinding expressions example

O código a seguir obtém o nome da fila para monitorar a partir de uma configuração de aplicativo, e ele obtém a hora de criação da mensagem da fila no parâmetro insertionTime.The following code gets the name of the queue to monitor from an app setting, and it gets the queue message creation time in the insertionTime parameter.

public static class BindingExpressionsExample
{
    [FunctionName("LogQueueMessage")]
    public static void Run(
        [QueueTrigger("%queueappsetting%")] string myQueueItem,
        DateTimeOffset insertionTime,
        ILogger log)
    {
        log.LogInformation($"Message content: {myQueueItem}");
        log.LogInformation($"Created at: {insertionTime}");
    }
}

function.json gerado automaticamenteAutogenerated function.json

O processo de compilação cria um arquivo function.json em uma pasta de função na pasta de compilação.The build process creates a function.json file in a function folder in the build folder. Conforme observado anteriormente, esse arquivo não deve ser editado diretamente.As noted earlier, this file is not meant to be edited directly. Você não pode alterar a configuração de associação ou desabilitar a função por meio da edição desse arquivo.You can't change binding configuration or disable the function by editing this file.

O objetivo desse arquivo é fornecer informações para o controlador de escala usado para dimensionar decisões no plano de consumo.The purpose of this file is to provide information to the scale controller to use for scaling decisions on the consumption plan. Por esse motivo, o arquivo não tem informações de associações de entrada ou saída, apenas de gatilho.For this reason, the file only has trigger info, not input or output bindings.

O arquivo function.json gerado inclui uma propriedade configurationSource que indica o runtime a ser usado em atributos .NET para associações, em vez da configuração do function.json.The generated function.json file includes a configurationSource property that tells the runtime to use .NET attributes for bindings, rather than function.json configuration. Aqui está um exemplo:Here's an example:

{
  "generatedBy": "Microsoft.NET.Sdk.Functions-1.0.0.0",
  "configurationSource": "attributes",
  "bindings": [
    {
      "type": "queueTrigger",
      "queueName": "%input-queue-name%",
      "name": "myQueueItem"
    }
  ],
  "disabled": false,
  "scriptFile": "..\\bin\\FunctionApp1.dll",
  "entryPoint": "FunctionApp1.QueueTrigger.Run"
}

Microsoft.NET.Sdk.FunctionsMicrosoft.NET.Sdk.Functions

A geração do arquivo function.json é realizada pelo pacote NuGet Microsoft.NET.Sdk.Functions.The function.json file generation is performed by the NuGet package Microsoft.NET.Sdk.Functions.

O mesmo pacote é usado para a versão 1.x e 2.x do runtime do Functions.The same package is used for both version 1.x and 2.x of the Functions runtime. A estrutura de destino é o que diferencia um projeto de 1.x de um projeto de 2.x.The target framework is what differentiates a 1.x project from a 2.x project. Estas são as partes relevantes dos arquivos .csproj, mostrando estruturas de destino diferentes e o mesmo pacote Sdk:Here are the relevant parts of .csproj files, showing different target frameworks and the same Sdk package:

Functions 1.xFunctions 1.x

<PropertyGroup>
  <TargetFramework>net461</TargetFramework>
</PropertyGroup>
<ItemGroup>
  <PackageReference Include="Microsoft.NET.Sdk.Functions" Version="1.0.8" />
</ItemGroup>

Functions 2.xFunctions 2.x

<PropertyGroup>
  <TargetFramework>netcoreapp2.1</TargetFramework>
  <AzureFunctionsVersion>v2</AzureFunctionsVersion>
</PropertyGroup>
<ItemGroup>
  <PackageReference Include="Microsoft.NET.Sdk.Functions" Version="1.0.8" />
</ItemGroup>

Entre as dependências do pacote Sdk estão os gatilhos e associações.Among the Sdk package dependencies are triggers and bindings. Um projeto 1. x refere-se a gatilhos e associações de 1. x porque esses gatilhos e associações se destinam ao .NET Framework, enquanto os gatilhos de 2. x e associações são direcionadas ao .NET Core.A 1.x project refers to 1.x triggers and bindings because those triggers and bindings target the .NET Framework, while 2.x triggers and bindings target .NET Core.

O pacote Sdk também depende do Newtonsoft.Json e, indiretamente, do WindowsAzure.Storage.The Sdk package also depends on Newtonsoft.Json, and indirectly on WindowsAzure.Storage. Essas dependências garantem que seu projeto use as versões desses pacotes que funcionam com a versão de runtime do Functions para a qual o projeto é direcionado.These dependencies make sure that your project uses the versions of those packages that work with the Functions runtime version that the project targets. Por exemplo, o Newtonsoft.Json tem a versão 11 para o .NET Framework 4.6.1, mas o runtime do Functions direcionado para o .NET Framework 4.6.1 só é compatível com o Newtonsoft.Json 9.0.1.For example, Newtonsoft.Json has version 11 for .NET Framework 4.6.1, but the Functions runtime that targets .NET Framework 4.6.1 is only compatible with Newtonsoft.Json 9.0.1. Portanto, o código de sua função nesse projeto também tem que usar Newtonsoft.Json 9.0.1.So your function code in that project also has to use Newtonsoft.Json 9.0.1.

O código-fonte para Microsoft.NET.Sdk.Functionsestá disponível no repositório GitHub azure-functions-vs-build-sdk.The source code for Microsoft.NET.Sdk.Functions is available in the GitHub repo azure-functions-vs-build-sdk.

Versão de runtimeRuntime version

O Visual Studio usa as Ferramentas Essenciais do Azure Functions para executar projetos do Functions.Visual Studio uses the Azure Functions Core Tools to run Functions projects. As Ferramentas Essenciais são uma interface de linha de comando para o runtime do Functions.The Core Tools is a command-line interface for the Functions runtime.

Se você instalar as Ferramentas Essenciais usando npm, isso não afetará a versão das Ferramentas Essenciais usada pelo Visual Studio.If you install the Core Tools by using npm, that doesn't affect the Core Tools version used by Visual Studio. Para a versão de runtime do Functions 1.x, o Visual Studio armazena as versões das Ferramentas Essenciais em %USERPROFILE%\AppData\Local\Azure.Functions.Cli e usa a versão mais recente armazenada ali.For the Functions runtime version 1.x, Visual Studio stores Core Tools versions in %USERPROFILE%\AppData\Local\Azure.Functions.Cli and uses the latest version stored there. Para o Functions 2.x, as Ferramentas Essenciais serão incluídas na extensão Azure Functions e Ferramentas de Trabalhos Web.For Functions 2.x, the Core Tools are included in the Azure Functions and Web Jobs Tools extension. Para 1.x e 2.x, você pode ver qual versão está sendo usado na saída do console ao executar um projeto do Functions:For both 1.x and 2.x, you can see what version is being used in the console output when you run a Functions project:

[3/1/2018 9:59:53 AM] Starting Host (HostId=contoso2-1518597420, Version=2.0.11353.0, ProcessId=22020, Debug=False, Attempt=0, FunctionsExtensionVersion=)

Tipos com suporte para associaçõesSupported types for bindings

Cada associação tem seus próprios tipos com suporte. Por exemplo, um atributo de gatilho de blob pode ser aplicado a um parâmetro de cadeia de caracteres, um parâmetro POCO, um parâmetro CloudBlockBlob ou qualquer um dos vários outros tipos com suporte.Each binding has its own supported types; for instance, a blob trigger attribute can be applied to a string parameter, a POCO parameter, a CloudBlockBlob parameter, or any of several other supported types. O artigo de referência de associação para associações de blob lista todos os tipos de parâmetro com suporte.The binding reference article for blob bindings lists all supported parameter types. Para obter mais informações, consulte Gatilhos e associações e os documentos de referência de associação para cada tipo de associação.For more information, see Triggers and bindings and the binding reference docs for each binding type.

Dica

Se você planeja usar as ligações HTTP ou WebHook, planeje evitar o esgotamento de porta que pode ser causado pela instanciação incorreta do HttpClient.If you plan to use the HTTP or WebHook bindings, plan to avoid port exhaustion that can be caused by improper instantiation of HttpClient. Para saber mais, confira Como gerenciar conexões no Azure Functions.For more information, see How to manage connections in Azure Functions.

Associando ao valor de retorno do métodoBinding to method return value

Você pode usar um valor de retorno do método para uma associação de saída, aplicando o atributo ao valor de retorno do método.You can use a method return value for an output binding, by applying the attribute to the method return value. Para obter exemplos, consulte Gatilhos e associações.For examples, see Triggers and bindings.

Use o valor retornado apenas se uma execução de função com êxito sempre resultar em um valor retornado a ser passado para a associação de saída.Use the return value only if a successful function execution always results in a return value to pass to the output binding. Caso contrário, use ICollector ou IAsyncCollector, conforme mostrado na seção a seguir.Otherwise, use ICollector or IAsyncCollector, as shown in the following section.

Gravando vários valores de saídaWriting multiple output values

Para gravar vários valores em uma associação de saída ou se uma invocação de função com êxito não resultar em nada a ser passado para a associação de saída, use os tipos ICollector ou IAsyncCollector.To write multiple values to an output binding, or if a successful function invocation might not result in anything to pass to the output binding, use the ICollector or IAsyncCollector types. 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.These types are write-only collections that are written to the output binding when the method completes.

Este exemplo grava várias mensagens de fila na mesma fila usando ICollector:This example writes multiple queue messages into the same queue using ICollector:

public static class ICollectorExample
{
    [FunctionName("CopyQueueMessageICollector")]
    public static void Run(
        [QueueTrigger("myqueue-items-source-3")] string myQueueItem,
        [Queue("myqueue-items-destination")] ICollector<string> myDestinationQueue,
        ILogger log)
    {
        log.LogInformation($"C# function processed: {myQueueItem}");
        myDestinationQueue.Add($"Copy 1: {myQueueItem}");
        myDestinationQueue.Add($"Copy 2: {myQueueItem}");
    }
}

Registro em logLogging

A saída de log para logs de streaming em C#, inclue um argumento do tipo ILogger.To log output to your streaming logs in C#, include an argument of type ILogger. É recomendável que você nomeie log, conforme mostrado no exemplo a seguir:We recommend that you name it log, as in the following example:

public static class SimpleExample
{
    [FunctionName("QueueTrigger")]
    public static void Run(
        [QueueTrigger("myqueue-items")] string myQueueItem, 
        ILogger log)
    {
        log.LogInformation($"C# function processed: {myQueueItem}");
    }
} 

Evite usar Console.Write no Azure Functions.Avoid using Console.Write in Azure Functions. Para obter mais informações, consulte Gravar logs mas funções C# no artigo Monitorar o Azure Functions.For more information, see Write logs in C# functions in the Monitor Azure Functions article.

AssíncronoAsync

Para tornar uma função assíncrona, use a palavra-chave async e retorne um objeto Task.To make a function asynchronous, use the async keyword and return a Task object.

public static class AsyncExample
{
    [FunctionName("BlobCopy")]
    public static async Task RunAsync(
        [BlobTrigger("sample-images/{blobName}")] Stream blobInput,
        [Blob("sample-images-copies/{blobName}", FileAccess.Write)] Stream blobOutput,
        CancellationToken token,
        ILogger log)
    {
        log.LogInformation($"BlobCopy function processed.");
        await blobInput.CopyToAsync(blobOutput, 4096, token);
    }
}

Não é possível usar parâmetros out em funções assíncronas.You can't use out parameters in async functions. Para associações de saída, use o valor de retorno de função ou um objeto coletor.For output bindings, use the function return value or a collector object instead.

Tokens de cancelamentoCancellation tokens

Uma função pode aceitar um parâmetro CancellationToken que permite ao sistema operacional notificar seu código quando a função está prestes a ser encerrada.A function can accept a CancellationToken parameter, which enables the operating system to notify your code when the function is about to be terminated. Você pode usar essa notificação para certificar-se de que a função não finalize inesperadamente de uma maneira que os dados fiquem em um estado inconsistente.You can use this notification to make sure the function doesn't terminate unexpectedly in a way that leaves data in an inconsistent state.

O exemplo a seguir mostra como verificar o encerramento da função iminente.The following example shows how to check for impending function termination.

public static class CancellationTokenExample
{
    public static void Run(
        [QueueTrigger("inputqueue")] 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);
        }
    }
}

Variáveis de ambienteEnvironment variables

Para obter uma variável de ambiente ou um valor de configuração do aplicativo, use System.Environment.GetEnvironmentVariable, conforme mostrado no exemplo de código a seguir:To get an environment variable or an app setting value, use System.Environment.GetEnvironmentVariable, as shown in the following code example:

public static class EnvironmentVariablesExample
{
    [FunctionName("GetEnvironmentVariables")]
    public static void Run([TimerTrigger("0 */5 * * * *")]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);
    }
}

As configurações do aplicativo podem ser lidas de variáveis de ambiente ao desenvolver localmente e ao executar no Azure.App settings can be read from environment variables both when developing locally and when running in Azure. Ao desenvolver localmente, as configurações do aplicativo são provenientes da coleção Values no arquivo local.settings.json.When developing locally, app settings come from the Values collection in the local.settings.json file. Em ambos os ambientes, local e do Azure, GetEnvironmentVariable("<app setting name>") recupera o valor da configuração de aplicativo nomeada.In both environments, local and Azure, GetEnvironmentVariable("<app setting name>") retrieves the value of the named app setting. Por exemplo, quando você estivesse executando localmente, "Nome do Meu Site" seria retornado se o arquivo local.settings.json contivesse { "Values": { "WEBSITE_SITE_NAME": "My Site Name" } }.For instance, when you're running locally, "My Site Name" would be returned if your local.settings.json file contains { "Values": { "WEBSITE_SITE_NAME": "My Site Name" } }.

A propriedade System.Configuration.ConfigurationManager.AppSettings é uma API alternativa para obter os valores de configuração do aplicativo, mas é recomendável que você use GetEnvironmentVariable conforme mostrado aqui.The System.Configuration.ConfigurationManager.AppSettings property is an alternative API for getting app setting values, but we recommend that you use GetEnvironmentVariable as shown here.

Associando no runtimeBinding at runtime

No C# e em outras linguagens .NET, é possível usar um padrão de associação obrigatório em vez de associações declarativas em atributos.In C# and other .NET languages, you can use an imperative binding pattern, as opposed to the declarative bindings in attributes. A associação obrigatória é útil quando os parâmetros de associação precisam ser calculado no runtime, em vez do tempo de design.Imperative binding is useful when binding parameters need to be computed at runtime rather than design time. Com esse padrão, é possível se vincular a associações de entrada e saída com suporte instantaneamente no código da função.With this pattern, you can bind to supported input and output bindings on-the-fly in your function code.

Defina uma associação obrigatória da seguinte maneira:Define an imperative binding as follows:

  • Não inclua um atributo em na assinatura de função para as associações obrigatórias desejadas.Do not include an attribute in the function signature for your desired imperative bindings.

  • Passe um parâmetro de entrada Binder binder ou IBinder binder.Pass in an input parameter Binder binder or IBinder binder.

  • Use o padrão de C# a seguir para realizar a associação de dados.Use the following C# pattern to perform the data binding.

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

    BindingTypeAttribute é o atributo do .NET que define a associação, e T é um tipo de entrada ou saída com suporte nesse tipo de associação.BindingTypeAttribute is the .NET attribute that defines your binding, and T is an input or output type that's supported by that binding type. T não pode ser um tipo de parâmetro out (como out JObject).T cannot be an out parameter type (such as out JObject). Por exemplo, a associação de saída de tabela de aplicativos móveis dá suporte a seis tipos de saída, mas você só pode usar ICollector<t > ou IAsyncCollector<t > com associação imperativa.For example, the Mobile Apps table output binding supports six output types, but you can only use ICollector<T> or IAsyncCollector<T> with imperative binding.

Exemplo de atributo únicoSingle attribute example

O código de exemplo a seguir cria uma associação de saída do Armazenamento de Blobs com o caminho do blob definido em tempo de execução e grava uma cadeia de caracteres no blob.The following example code creates a Storage blob output binding with blob path that's defined at run time, then writes a string to the blob.

public static class IBinderExample
{
    [FunctionName("CreateBlobUsingBinder")]
    public static void Run(
        [QueueTrigger("myqueue-items-source-4")] string myQueueItem,
        IBinder binder,
        ILogger log)
    {
        log.LogInformation($"CreateBlobUsingBinder function processed: {myQueueItem}");
        using (var writer = binder.Bind<TextWriter>(new BlobAttribute(
                    $"samples-output/{myQueueItem}", FileAccess.Write)))
        {
            writer.Write("Hello World!");
        };
    }
}

BlobAttribute define a associação de entrada ou saída do Armazenamento de Blobs e TextWriter é um tipo de associação de saída com suporte.BlobAttribute defines the Storage blob input or output binding, and TextWriter is a supported output binding type.

Exemplo de atributo múltiploMultiple attribute example

O exemplo anterior obtém a configuração do aplicativo para a cadeia de conexão da conta de armazenamento principal do aplicativo de funções (que é AzureWebJobsStorage).The preceding example gets the app setting for the function app's main Storage account connection string (which is AzureWebJobsStorage). É possível especificar uma configuração de aplicativo personalizada a ser usada para a conta de armazenamento adicionando StorageAccountAttribute e passando a matriz de atributos para BindAsync<T>().You can specify a custom app setting to use for the Storage account by adding the StorageAccountAttribute and passing the attribute array into BindAsync<T>(). Use um parâmetro Binder, não IBinder.Use a Binder parameter, not IBinder. Por exemplo:For example:

public static class IBinderExampleMultipleAttributes
{
    [FunctionName("CreateBlobInDifferentStorageAccount")]
    public async static Task RunAsync(
            [QueueTrigger("myqueue-items-source-binder2")] string myQueueItem,
            Binder binder,
            ILogger log)
    {
        log.LogInformation($"CreateBlobInDifferentStorageAccount function processed: {myQueueItem}");
        var attributes = new Attribute[]
        {
        new BlobAttribute($"samples-output/{myQueueItem}", FileAccess.Write),
        new StorageAccountAttribute("MyStorageAccount")
        };
        using (var writer = await binder.BindAsync<TextWriter>(attributes))
        {
            await writer.WriteAsync("Hello World!!");
        }
    }
}

Gatilhos e associaçõesTriggers and bindings

Esta tabela mostra as associações com suporte nas versões principais do tempo de execução de Azure Functions:This table shows the bindings that are supported in the major versions of the Azure Functions runtime:

TypeType 1.x1.x 2. x e superior12.x and higher1 GatilhoTrigger EntradaInput SaídaOutput
Armazenamento de BlobsBlob storage
Cosmos DBCosmos DB
Grade de EventosEvent Grid
Hubs de EventosEvent Hubs
WebHooks de & de HTTPHTTP & webhooks
Hub IoTIoT Hub
Microsoft Graph
Tabelas do Excel
Microsoft Graph
Excel tables
Microsoft Graph
Arquivos do OneDrive
Microsoft Graph
OneDrive files
Microsoft Graph
Email do Outlook
Microsoft Graph
Outlook email
Microsoft Graph eventos de
Microsoft Graph
events
Microsoft Graph
Tokens de autenticação
Microsoft Graph
Auth tokens
Aplicativos MóveisMobile Apps
Hubs de NotificaçãoNotification Hubs
Armazenamento de filasQueue storage
SendGridSendGrid
Barramento de ServiçoService Bus
SignalRSignalR
Armazenamento de tabelasTable storage
TimerTimer
TwilioTwilio

1 a partir do tempo de execução da versão 2. x, todas as associações, exceto http e Timer, devem ser registradas.1 Starting with the version 2.x runtime, all bindings except HTTP and Timer must be registered. Confira Registrar as extensões de associação.See Register binding extensions.

Próximos passosNext steps