Referência do C# desenvolvedor de Funções AzureAzure Functions C# developer reference

Este artigo é uma introdução ao desenvolvimento C# de Funções Azure utilizando bibliotecas da classe .NET.This article is an introduction to developing Azure Functions by using C# in .NET class libraries.

As Funções C# Azure C# suportam e programam linguagens.Azure Functions supports C# and C# script programming languages. Se procura orientação sobre C# a utilização no portal Azure,consulte C# a referência do desenvolvedor script (.csx).If you're looking for guidance on using C# in the Azure portal, see C# script (.csx) developer reference.

Este artigo assume que já leu os seguintes artigos:This article assumes that you've already read the following articles:

Versões suportadasSupported versions

As versões do tempo de funcionamento das Funções funcionam com versões específicas de .NET.Versions of the Functions runtime work with specific versions of .NET. O quadro seguinte mostra o nível mais elevado de .NET Core e .NET Framework e .NET Core que podem ser usados com uma versão específica de Funções no 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.

Funções versão de tempo de execuçãoFunctions runtime version Versão Max .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 as versões de execução do Funcionamento do Azure FunctionsTo learn more, see Azure Functions runtime versions overview

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

No Estúdio Visual, o modelo de C# projeto Funções Azure cria um projeto de biblioteca de classes que contém os seguintes ficheiros:In Visual Studio, the Azure Functions project template creates a C# class library project that contains the following files:

  • host.json - armazena configurações de configuração que afetam todas as funções do projeto ao executar localmente ou em Azure.host.json - stores configuration settings that affect all functions in the project when running locally or in Azure.
  • local.settings.json - armazena as definições de aplicativos e as cordas de ligação que são usadas quando estão a funcionar localmente.local.settings.json - stores app settings and connection strings that are used when running locally. Este ficheiro contém segredos e não é publicado na sua aplicação de funções no Azure.This file contains secrets and isn't published to your function app in Azure. Em vez disso, adicione as definições da aplicação à sua aplicação de função.Instead, add app settings to your function app.

Ao construir o projeto, uma estrutura de pasta que se parece com o seguinte exemplo é gerada no diretório de saída de construçã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

Este diretório é o que é implantado na sua app de funções em Azure.This directory is what gets deployed to your function app in Azure. As extensões de encadernação exigidas na versão 2.x do tempo de funcionamento das Funções são adicionadas ao projeto como pacotes 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 construção cria um ficheiro function.json para cada função.The build process creates a function.json file for each function. Este ficheiro função.json não deve ser editado diretamente.This function.json file is not meant to be edited directly. Não pode alterar a configuração de ligação ou desativar a função editando este ficheiro.You can't change binding configuration or disable the function by editing this file. Para aprender a desativar uma função, consulte como desativar as funções.To learn how to disable a function, see How to disable functions.

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

Numa biblioteca de classes, uma função é um método estático com um FunctionName e um atributo de gatilho, como mostra o seguinte exemplo: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 ponto de entrada de função.The FunctionName attribute marks the method as a function entry point. O nome deve ser único dentro de 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. Os modelos de projeto criam frequentemente um método C# chamado Run, mas o nome do método pode ser qualquer nome de método válido.Project templates often create a method named Run, but the method name can be any valid C# method name.

O atributo do gatilho especifica o tipo de gatilho e liga os 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 é desencadeada por uma mensagem de fila, e a mensagem de fila é transmitida ao 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 de métodoMethod signature parameters

A assinatura do método pode conter parâmetros diferentes dos utilizados com o atributo do 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 pode incluir:Here are some of the additional parameters that you can include:

A ordem dos parâmetros na assinatura da função não importa.The order of parameters in the function signature does not matter. Por exemplo, pode colocar parâmetros de gatilho antes ou depois de outras ligações, e pode colocar o parâmetro do madeireiro antes ou depois do gatilho ou dos parâmetros de ligaçã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 encadernação de saídaOutput binding example

O exemplo seguinte modifica o anterior adicionando uma ligação de fila de saída.The following example modifies the preceding one by adding an output queue binding. A função escreve a mensagem de fila que desencadeia a função para uma nova mensagem de fila numa 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 ligação (filas dearmazenamento,por exemplo) explicam quais os tipos de parâmetros que pode utilizar com atributos de ligaçã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 vinculativasBinding expressions example

O código seguinte obtém o nome da fila para monitorizar a partir de uma definição de app, e obtém o tempo de criação de mensagens de 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}");
    }
}

Função autogerada.jsonAutogenerated function.json

O processo de construção cria um ficheiro function.json numa pasta de função na pasta de construção.The build process creates a function.json file in a function folder in the build folder. Como notado anteriormente, este ficheiro não deve ser editado diretamente.As noted earlier, this file is not meant to be edited directly. Não pode alterar a configuração de ligação ou desativar a função editando este ficheiro.You can't change binding configuration or disable the function by editing this file.

O objetivo deste ficheiro é fornecer informações ao controlador de escala para utilizar para decisõesde escala 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 esta razão, o ficheiro apenas tem informações de gatilho, não de ligações de entrada ou de saída.For this reason, the file only has trigger info, not input or output bindings.

O ficheiro função.json gerado inclui uma propriedade configurationSource que diz o tempo de funcionamento para usar atributos .NET para ligações, em vez de configuração 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. Segue-se 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 de ficheiros function.json é executada 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 é utilizado para ambas as versões 1.x e 2.x do tempo de funcionamento das Funções.The same package is used for both version 1.x and 2.x of the Functions runtime. O quadro-alvo é o que diferencia um projeto 1.x de um projeto 2.x.The target framework is what differentiates a 1.x project from a 2.x project. Aqui estão as partes relevantes dos ficheiros .csproj, mostrando diferentes quadros-alvo e o mesmo pacote Sdk:Here are the relevant parts of .csproj files, showing different target frameworks and the same Sdk package:

Funções 1.xFunctions 1.x

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

Funções 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 os Sdk dependências de pacotes estão gatilhos e encadernações.Among the Sdk package dependencies are triggers and bindings. Um projeto de 1.x refere-se a gatilhos e encadernações de 1.x porque esses gatilhos e encadernações visam o Quadro .NET, enquanto 2.x desencadeia e encaderna o alvo .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 da Newtonsoft.Json,e indiretamente do WindowsAzure.Storage.The Sdk package also depends on Newtonsoft.Json, and indirectly on WindowsAzure.Storage. Estas dependências certificam-se de que o seu projeto utiliza as versões dos pacotes que funcionam com a versão de tempo de execução functions que o projeto tem como alvo.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, Newtonsoft.Json tem a versão 11 para .NET Framework 4.6.1, mas o tempo de funcionamento das funções que visa .NET Framework 4.6.1 só é compatível com 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. Assim, o seu código de funcionamento nesse projeto também tem de 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.Functions está disponível nas funções de-de do GitHub -vs-construir-sdk.The source code for Microsoft.NET.Sdk.Functions is available in the GitHub repo azure-functions-vs-build-sdk.

Versão runtimeRuntime version

O Visual Studio utiliza as Ferramentas Core funções do Azure para executar projetos de funções.Visual Studio uses the Azure Functions Core Tools to run Functions projects. As Ferramentas Core são uma interface de linha de comando para o tempo de funcionamento das funções.The Core Tools is a command-line interface for the Functions runtime.

Se instalar as Ferramentas Core utilizando o npm, isso não afeta a versão Core Tools utilizada 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 as funções runtime versão 1.x, visual Studio armazena versões Core Tools em %USERPROFILE%\AppData\Local\Azure.Functions.Functions.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 funções 2.x, as Ferramentas Core estão incluídas na extensão de Ferramentas de Funcionamento Azul e Web Jobs.For Functions 2.x, the Core Tools are included in the Azure Functions and Web Jobs Tools extension. Tanto para 1.x como 2.x, pode supor que versão está a ser utilizada na saída da consola quando executa um projeto 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 suportados para encadernaçõesSupported types for bindings

Cada encadernação tem os seus próprios tipos suportados; por exemplo, um atributo do gatilho de bolha pode ser aplicado a um parâmetro de corda, um parâmetro POCO, um parâmetro CloudBlockBlob ou qualquer um de vários outros tipos suportados.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 vinculativo para encadernações blob lista todos os tipos de parâmetros suportados.The binding reference article for blob bindings lists all supported parameter types. Para mais informações, consulte Gatilhos e encadernações e os docs de referência vinculativos para cada tipo de encadernação.For more information, see Triggers and bindings and the binding reference docs for each binding type.

Dica

Se planeja usar os enlaces de HTTP ou WebHook, planeie evitar o esgotamento de porta que pode ser causado por instâncias impróprias de 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 obter mais informações, consulte como gerir ligações nas funções do Azure.For more information, see How to manage connections in Azure Functions.

Vinculação ao valor de retorno do métodoBinding to method return value

Pode utilizar um valor de devolução de método para uma ligaçã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. Por exemplo, consulte Gatilhos e encadernações.For examples, see Triggers and bindings.

Utilize o valor de devolução apenas se uma execução de função bem sucedida resultar sempre num valor de retorno para passar para a ligaçã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, utilize ICollector ou IAsyncCollector, como se pode ver na secção seguinte.Otherwise, use ICollector or IAsyncCollector, as shown in the following section.

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

Para escrever vários valores para 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 ligação de saída, use os tiposICollector 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. Estes tipos são coleções escritas apenas que são escritas para a ligação de saída quando o método completa.These types are write-only collections that are written to the output binding when the method completes.

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

RegistoLogging

Para iniciar sessão nos C#seus registos de streaming, inclua um argumento do tipo ILogger.To log output to your streaming logs in C#, include an argument of type ILogger. Recomendamos que o nomeie log, como no seguinte exemplo: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 utilizar Console.Write em funções Azure.Avoid using Console.Write in Azure Functions. Para mais informações, consulte os registos de escrita em C# funções no artigo Funções Monitor Azure.For more information, see Write logs in C# functions in the Monitor Azure Functions article.

AsyncAsync

Para fazer uma função assíncrona,use a palavra-chave async e devolva 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 se pode usar out parâmetros em funções de asincronização.You can't use out parameters in async functions. Para encadernações de saída, utilize o valor de devolução da função ou um objeto de coleção.For output bindings, use the function return value or a collector object instead.

Fichas de cancelamentoCancellation tokens

Uma função pode aceitar um parâmetro CancelamentoToken, que permite ao sistema operativo notificar o seu código quando a função está prestes a ser terminada.A function can accept a CancellationToken parameter, which enables the operating system to notify your code when the function is about to be terminated. Pode utilizar esta notificação para se certificar de que a função não termina inesperadamente de uma forma que deixe os dados num 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 que se segue mostra como verificar se há uma interrupção 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 ambiental ou um valor de definição de app, use System.Environment.GetEnvironmentVariable, como mostra o seguinte exemplo de código: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 definições de aplicativos podem ser lidas a partir de variáveis ambientais tanto quando se desenvolve localmente como quando se está a correr em Azure.App settings can be read from environment variables both when developing locally and when running in Azure. Ao desenvolver localmente, as definições de aplicativos provêm da recolha Values no ficheiro 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 Azure, GetEnvironmentVariable("<app setting name>") recupera o valor da configuração de aplicações nomeada.In both environments, local and Azure, GetEnvironmentVariable("<app setting name>") retrieves the value of the named app setting. Por exemplo, quando estiver a funcionar localmente, "My Site Name" seria devolvido se o seu ficheiro local.settings.json contiver { "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.ConfigurationManager.AppSettings é uma API alternativa para obter valores de definição de aplicações, mas recomendamos que utilize GetEnvironmentVariable como 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.

Encadernação no tempo de execuçãoBinding at runtime

Dentro C# e noutras línguas .NET, você pode usar um padrão de ligação imperativo, em oposição às ligaçõ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 ligação imperativa é útil quando os parâmetros de ligação precisam de ser calculados no tempo de execução em vez de tempo de conceção.Imperative binding is useful when binding parameters need to be computed at runtime rather than design time. Com este padrão, pode ligar-se a encadernações de entrada e saída suportadas no seu código de função.With this pattern, you can bind to supported input and output bindings on-the-fly in your function code.

Defina uma vinculação imperativa da seguinte forma:Define an imperative binding as follows:

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

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

  • Utilize o C# seguinte padrão para efetuar a encadernaçã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 .NET que define a sua ligação, e T é um tipo de entrada ou saída que é suportado por esse tipo de ligaçã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 do tipo de parâmetro out (como out JObject).T cannot be an out parameter type (such as out JObject). Por exemplo, a ligação de saída da tabela Mobile Apps suporta seis tipos de saída,mas só pode utilizar o ICollector<T> ou o IAsyncCollector<T> com uma ligaçã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 seguinte código de exemplo cria uma ligação de saída de blob de armazenamento com caminho blob que é definido no tempo de execução, em seguida, escreve uma corda para a bolha.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 entrada ou ligação de saída da bolha de armazenamento, e textWriter é um tipo de ligação de saída suportado.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 definição da aplicação para a cadeia de ligação à conta de armazenamento principal da aplicação de função (que é AzureWebJobsStorage).The preceding example gets the app setting for the function app's main Storage account connection string (which is AzureWebJobsStorage). Pode especificar uma definição de aplicação personalizada para usar na conta de Armazenamento, adicionando o StorageAccountAttribute e passando o conjunto 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>(). Utilize 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!!");
        }
    }
}

Acionadores e enlacesTriggers and bindings

Esta tabela mostra as encadernações que são suportadas nas principais versões do tempo de funcionamento das Funções Azure:This table shows the bindings that are supported in the major versions of the Azure Functions runtime:

TipoType 1.x1.x 2.x e superior12.x and higher1 AcionadorTrigger InputInput SaídaOutput
Armazenamento de blobsBlob storage
BD do CosmosCosmos DB
Event GridEvent Grid
Hubs de EventosEvent Hubs
HTTP e webhooksHTTP & webhooks
Hub IoTIoT Hub
Tabelas do Microsoft Graph
Excel
Microsoft Graph
Excel tables
Microsoft Graph
ficheiros OneDrive
Microsoft Graph
OneDrive files
E-mail do Microsoft Graph
Outlook
Microsoft Graph
Outlook email
Eventos
do Microsoft Graph
Microsoft Graph
events
Fichas
Microsoft Graph Auth
Microsoft Graph
Auth tokens
Aplicações MóveisMobile Apps
Hubs de NotificaçãoNotification Hubs
Armazenamento de filasQueue storage
SendGridSendGrid
Service BusService Bus
SinaleiroSignalR
Armazenamento de tabelasTable storage
TemporizadorTimer
TwilioTwilio

1 A partir do tempo de execução da versão 2.x, todas as encadernações, exceto HTTP e Temporizador, devem ser registadas.1 Starting with the version 2.x runtime, all bindings except HTTP and Timer must be registered. Ver Registar extensões de encadernação.See Register binding extensions.

Passos seguintesNext steps