Referência do C# desenvolvedor de funções azure (.csx)Azure Functions C# script (.csx) developer reference

Este artigo é uma introdução ao desenvolvimento C# de Funções Azure utilizando o script (.csx).This article is an introduction to developing Azure Functions by using C# script (.csx).

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 de um projetode biblioteca de classe Visual Studio, consulte C# a referência do desenvolvedor.If you're looking for guidance on using C# in a Visual Studio class library project, see C# developer reference.

Este artigo assume que já leu o guia de desenvolvedores de Funções Azure.This article assumes that you've already read the Azure Functions developers guide.

Como funciona .csxHow .csx works

A C# experiência do script para funções Azure baseia-se no Azure WebJobs SDK.The C# script experience for Azure Functions is based on the Azure WebJobs SDK. Os dados C# fluem para a sua função através de argumentos de método.Data flows into your C# function via method arguments. Os nomes de argumentos são especificados num ficheiro function.json, e existem nomes predefinidos para aceder a coisas como o logger de funções e fichas de cancelamento.Argument names are specified in a function.json file, and there are predefined names for accessing things like the function logger and cancellation tokens.

O formato .csx permite-lhe escrever menos "placa C# de caldeira" e concentrar-se na escrita apenas uma função.The .csx format allows you to write less "boilerplate" and focus on writing just a C# function. Em vez de embrulhar tudo num espaço de nome e classe, apenas defina um método Run.Instead of wrapping everything in a namespace and class, just define a Run method. Inclua quaisquer referências de montagem e espaços de nome no início do ficheiro, como de costume.Include any assembly references and namespaces at the beginning of the file as usual.

Os ficheiros .csx de uma aplicação de função são compilados quando uma instância é inicializada.A function app's .csx files are compiled when an instance is initialized. Este passo de compilação significa que C# coisas como o C# arranque a frio podem demorar mais tempo para as funções do script em comparação com as bibliotecas de classes.This compilation step means things like cold start may take longer for C# script functions compared to C# class libraries. Este passo de compilação é também por isso que C# as C# funções de script são editáveis no portal Azure, enquanto as bibliotecas de classes não são.This compilation step is also why C# script functions are editable in the Azure portal, while C# class libraries are not.

Estrutura de pastaFolder structure

A estrutura da C# pasta para um projeto de script parece ser a seguinte:The folder structure for a C# script project looks like the following:

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

Há um ficheiro host.json partilhado que pode ser usado para configurar a aplicação de função.There's a shared host.json file that can be used to configure the function app. Cada função tem o seu próprio ficheiro de código (.csx) e ficheiro de configuração de ligação (função.json).Each function has its own code file (.csx) and binding configuration file (function.json).

As extensões de encadernação exigidas na versão 2.x e versões posteriores do tempo de execução das Funções são definidas no ficheiro extensions.csproj, com os ficheiros da biblioteca reais na pasta bin.The binding extensions required in version 2.x and later versions of the Functions runtime are defined in the extensions.csproj file, with the actual library files in the bin folder. Ao desenvolver-se localmente, deve registar extensões vinculativas.When developing locally, you must register binding extensions. Ao desenvolver funções no portal Azure, este registo é feito para si.When developing functions in the Azure portal, this registration is done for you.

Vinculativo aos argumentosBinding to arguments

Os dados de entrada ou C# saída estão ligados a um parâmetro de função de script através da propriedade name no ficheiro de configuração function.json.Input or output data is bound to a C# script function parameter via the name property in the function.json configuration file. O exemplo seguinte mostra um ficheiro function.json e ficheiro run.csx para uma função ativada pela fila.The following example shows a function.json file and run.csx file for a queue-triggered function. O parâmetro que recebe dados da mensagem de fila chama-se myQueueItem porque é esse o valor da propriedade name.The parameter that receives data from the queue message is named myQueueItem because that's the value of the name property.

{
    "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 declaração #r é explicada mais tarde neste artigo.The #r statement is explained later in this article.

Tipos suportados para encadernaçõesSupported types for bindings

Cada encadernação tem os seus próprios tipos suportados; por exemplo, um gatilho de bolha pode ser usado com 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 can be used with 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 para os gatilhos de bolhas.The binding reference article for blob bindings lists all supported parameter types for blob triggers. 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.

Referenciar aulas personalizadasReferencing custom classes

Se precisar de utilizar uma classe personalizada de Objeto CLR (POCO) personalizado, pode incluir a definição de classe dentro do mesmo ficheiro ou colocá-la num ficheiro separado.If you need to use a custom Plain Old CLR Object (POCO) class, you can include the class definition inside the same file or put it in a separate file.

O exemplo que se segue mostra um exemplo run.csx que inclui uma definição de classe POCO.The following example shows a run.csx example that includes a POCO class definition.

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.A POCO class must have a getter and setter defined for each property.

Reutilizar o código .csxReusing .csx code

Pode utilizar classes e métodos definidos noutros ficheiros .csx no ficheiro run.csx.You can use classes and methods defined in other .csx files in your run.csx file. Para isso, use #load diretivas no seu ficheiro run.csx.To do that, use #load directives in your run.csx file. No exemplo seguinte, uma rotina de exploração madeireira chamada MyLogger é partilhada em myLogger.csx e carregada em run.csx usando a diretiva #load:In the following example, a logging routine named MyLogger is shared in myLogger.csx and loaded into run.csx using the #load directive:

Exemplo run.csx:Example 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:Example mylogger.csx:

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

Usar um ficheiro .csx partilhado é um padrão comum quando se pretende escrever fortemente os dados passados entre funções utilizando um objeto POCO.Using a shared .csx file is a common pattern when you want to strongly type the data passed between functions by using a POCO object. No exemplo simplificado seguinte, um gatilho http e o gatilho da fila partilham um objeto POCO chamado Order para escrever fortemente os dados da encomenda:In the following simplified example, an HTTP trigger and queue trigger share a POCO object named Order to strongly type the order data:

Exemplo run.csx para o gatilho HTTP:Example run.csx for HTTP trigger:

#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 o gatilho da fila:Example run.csx for queue trigger:

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

Ordem exemplo.csx:Example 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}";
    }
}

Pode utilizar um caminho relativo com a diretiva #load:You can use a relative path with the #load directive:

  • #load "mylogger.csx" carrega um ficheiro localizado na pasta de funções.#load "mylogger.csx" loads a file located in the function folder.
  • #load "loadedfiles\mylogger.csx" carrega um ficheiro localizado numa pasta na pasta de funções.#load "loadedfiles\mylogger.csx" loads a file located in a folder in the function folder.
  • #load "..\shared\mylogger.csx" carrega um ficheiro localizado numa pasta ao mesmo nível da pasta de funções, ou seja, diretamente em wwwroot.#load "..\shared\mylogger.csx" loads a file located in a folder at the same level as the function folder, that is, directly under wwwroot.

A diretiva #load funciona apenas com ficheiros .csx, não com ficheiros .cs.The #load directive works only with .csx files, not with .cs files.

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, utilizando o nome $return em função.json.You can use a method return value for an output binding, by using the name $return in function.json. 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 void Run(ICollector<string> myQueue, ILogger log)
{
    myQueue.Add("Hello");
    myQueue.Add("World!");
}

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.We recommend that you name it log. Evite utilizar Console.Write em funções Azure.Avoid using Console.Write in Azure Functions.

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

Nota

Para obter informações sobre uma nova estrutura de registo supérbio que pode utilizar em vez de TraceWriter, consulte registos de escrita em C# funções no artigo Funções Monitor Azure.For information about a newer logging framework that you can use instead of TraceWriter, 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 async static Task ProcessQueueMessageAsync(
        string blobName,
        Stream blobInput,
        Stream blobOutput)
{
    await blobInput.CopyToAsync(blobOutput, 4096);
}

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.

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

Espaços de nomes importandoImporting namespaces

Se precisar de importar espaços com nomes, pode fazê-lo como de costume, com a cláusula using.If you need to import namespaces, you can do so as usual, with the using clause.

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

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

Os seguintes espaços de nome são automaticamente importados e, portanto, são facultativos:The following namespaces are automatically imported and are therefore optional:

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

Referenciação de conjuntos externosReferencing external assemblies

Para os conjuntos-quadro, adicione referências utilizando a diretiva #r "AssemblyName".For framework assemblies, add references by using the #r "AssemblyName" directive.

#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 seguintes conjuntos são automaticamente adicionados pelo ambiente de hospedagem das Funções Azure:The following assemblies are automatically added by the Azure Functions hosting environment:

  • 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 conjuntos podem ser referenciados por nome simples (por exemplo, #r "AssemblyName"):The following assemblies may be referenced by simple-name (for example, #r "AssemblyName"):

  • Newtonsoft.Json
  • Microsoft.WindowsAzure.Storage
  • Microsoft.ServiceBus
  • Microsoft.AspNet.WebHooks.Receivers
  • Microsoft.AspNet.WebHooks.Common
  • Microsoft.Azure.NotificationHubs

Referenciação de conjuntos personalizadosReferencing custom assemblies

Para fazer referência a um conjunto personalizado, pode utilizar um conjunto partilhado ou um conjunto privado:To reference a custom assembly, you can use either a shared assembly or a private assembly:

  • As assembléias partilhadas são partilhadas em todas as funções dentro de uma aplicação de função.Shared assemblies are shared across all functions within a function app. Para fazer referência a um conjunto personalizado, faça o upload do conjunto para uma pasta chamada bin na pasta raiz da sua app de função (wwwroot).To reference a custom assembly, upload the assembly to a folder named bin in your function app root folder (wwwroot).

  • As assembleias privadas fazem parte do contexto de uma determinada função e suportam o carregamento lateral de diferentes versões.Private assemblies are part of a given function's context, and support side-loading of different versions. As assembleias privadas devem ser colocadas numa pasta bin no diretório de funções.Private assemblies should be uploaded in a bin folder in the function directory. Faça referência aos conjuntos utilizando o nome do ficheiro, como #r "MyAssembly.dll".Reference the assemblies using the file name, such as #r "MyAssembly.dll".

Para obter informações sobre como enviar ficheiros para a sua pasta de funções, consulte a secção na gestãodo pacote .For information on how to upload files to your function folder, see the section on package management.

Diretórios assistidosWatched directories

O diretório que contém o ficheiro do script de função é automaticamente observado para alterações nas assembléias.The directory that contains the function script file is automatically watched for changes to assemblies. Para ter em conta as alterações de montagem noutras direções, adicione-as à lista de watchDirectories no host.json.To watch for assembly changes in other directories, add them to the watchDirectories list in host.json.

Usando pacotes NuGetUsing NuGet packages

Para utilizar os pacotes NuGet numa C# função 2.x e posterior, faça upload de um ficheiro function.proj para a pasta da função no sistema de ficheiros da aplicação de função.To use NuGet packages in a 2.x and later C# function, upload a function.proj file to the function's folder in the function app's file system. Aqui está um ficheiro fun.proj de exemplo que adiciona uma referência a Microsoft.ProjectOxford.Face versão 1.1.0:Here is an example function.proj file that adds a reference to Microsoft.ProjectOxford.Face version 1.1.0:

<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <TargetFramework>netstandard2.0</TargetFramework>
    </PropertyGroup>

    <ItemGroup>
        <PackageReference Include="Microsoft.ProjectOxford.Face" Version="1.1.0" />
    </ItemGroup>
</Project>

Para utilizar um feed NuGet personalizado, especifique o feed num ficheiro Nuget.Config na raiz da App função.To use a custom NuGet feed, specify the feed in a Nuget.Config file in the Function App root. Para mais informações, consulte configurar o comportamento do NuGet.For more information, see Configuring NuGet behavior.

Nota

Em funções C# 1.x, os pacotes NuGet são referenciados com um ficheiro project.json em vez de um ficheiro function.proj.In 1.x C# functions, NuGet packages are referenced with a project.json file instead of a function.proj file.

Para funções de 1.x, utilize um ficheiro project.json.For 1.x functions, use a project.json file instead. Aqui está um arquivo de projeto.json exemplo:Here is an example project.json file:

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

Usando um ficheiro function.projUsing a function.proj file

  1. Abra a função no portal Azure.Open the function in the Azure portal. O separador de registos mostra a saída de instalação do pacote.The logs tab displays the package installation output.
  2. Para fazer o upload de um ficheiro function.proj, utilize um dos métodos descritos no tópico de referência da função Como atualizar os ficheiros de aplicações de funções no tópico de referência do desenvolvedor de Funções Azure.To upload a function.proj file, use one of the methods described in the How to update function app files in the Azure Functions developer reference topic.
  3. Depois de o ficheiro function.proj ser carregado, vê a saída como o seguinte exemplo no registo de streaming da sua função:After the function.proj file is uploaded, you see output like the following example in your function's streaming log:
2018-12-14T22:00:48.658 [Information] Restoring packages.
2018-12-14T22:00:48.681 [Information] Starting packages restore
2018-12-14T22:00:57.064 [Information] Restoring packages for D:\local\Temp\9e814101-fe35-42aa-ada5-f8435253eb83\function.proj...
2016-04-04T19:02:50.511 Restoring packages for D:\home\site\wwwroot\HttpTriggerCSharp1\function.proj...
2018-12-14T22:01:00.844 [Information] Installing Newtonsoft.Json 10.0.2.
2018-12-14T22:01:01.041 [Information] Installing Microsoft.ProjectOxford.Common.DotNetStandard 1.0.0.
2018-12-14T22:01:01.140 [Information] Installing Microsoft.ProjectOxford.Face.DotNetStandard 1.0.0.
2018-12-14T22:01:09.799 [Information] Restore completed in 5.79 sec for D:\local\Temp\9e814101-fe35-42aa-ada5-f8435253eb83\function.proj.
2018-12-14T22:01:10.905 [Information] Packages restored.

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

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

Em C# e noutras línguas .NET, você pode usar um padrão de ligação imperativo, em oposição às encadernações declarativas em função.json.In C# and other .NET languages, you can use an imperative binding pattern, as opposed to the declarative bindings in function.json. 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 uma entrada em função.json para as suas encadernações imperativas desejadas.Do not include an entry in function.json 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 IAsyncCollector<T> para T.For example, the Mobile Apps table output binding supports six output types, but you can only use ICollector<T> or IAsyncCollector<T> for T.

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.

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 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:

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 seguinte lista os atributos .NET para cada tipo de encadernação e as embalagens em que são definidos.The following table lists the .NET attributes for each binding type and the packages in which they are defined.

VínculoBinding AtributoAttribute Adicionar referênciaAdd reference
BD do CosmosCosmos DB Microsoft.Azure.WebJobs.DocumentDBAttribute #r "Microsoft.Azure.WebJobs.Extensions.CosmosDB"
Hubs de EventosEvent Hubs Microsoft.Azure.WebJobs.ServiceBus.EventHubAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttributeMicrosoft.Azure.WebJobs.ServiceBus.EventHubAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttribute #r "Microsoft.Azure.Jobs.ServiceBus"
Mobile AppsMobile Apps Microsoft.Azure.WebJobs.MobileTableAttribute #r "Microsoft.Azure.WebJobs.Extensions.MobileApps"
Hubs de NotificaçãoNotification Hubs Microsoft.Azure.WebJobs.NotificationHubAttribute #r "Microsoft.Azure.WebJobs.Extensions.NotificationHubs"
Service BusService Bus Microsoft.Azure.WebJobs.ServiceBusAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttributeMicrosoft.Azure.WebJobs.ServiceBusAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttribute #r "Microsoft.Azure.WebJobs.ServiceBus"
Fila de armazenamentoStorage queue Microsoft.Azure.WebJobs.QueueAttribute, Microsoft.Azure.WebJobs.StorageAccountAttributeMicrosoft.Azure.WebJobs.QueueAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
Blob de armazenamentoStorage blob Microsoft.Azure.WebJobs.BlobAttribute, Microsoft.Azure.WebJobs.StorageAccountAttributeMicrosoft.Azure.WebJobs.BlobAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
Mesa de armazenamentoStorage table Microsoft.Azure.WebJobs.TableAttribute, Microsoft.Azure.WebJobs.StorageAccountAttributeMicrosoft.Azure.WebJobs.TableAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
TwilioTwilio Microsoft.Azure.WebJobs.TwilioSmsAttribute #r "Microsoft.Azure.WebJobs.Extensions.Twilio"

Passos seguintesNext steps