Guida di riferimento a Funzioni di Azure per sviluppatori di script C# (.csx)Azure Functions C# script (.csx) developer reference

Questo articolo riporta un'introduzione allo sviluppo di Funzioni di Azure tramite script C# (.csx).This article is an introduction to developing Azure Functions by using C# script (.csx).

Funzioni di Azure supporta i linguaggi di programmazione C# e script C# .Azure Functions supports C# and C# script programming languages. Per materiale sussidiario sull'uso di C# in un progetto di libreria di classi di Visual Studio, vedere Informazioni di riferimento per sviluppatori C#.If you're looking for guidance on using C# in a Visual Studio class library project, see C# developer reference.

Questo articolo presuppone che l'utente abbia già letto il Manuale dello sviluppatore di Funzioni di Azure.This article assumes that you've already read the Azure Functions developers guide.

Funzionamento di CSXHow .csx works

L'esperienza con gli script C# per Funzioni di Azure si basa su Azure WebJobs SDK.The C# script experience for Azure Functions is based on the Azure WebJobs SDK. I dati vengono trasmessi alla funzione C# tramite argomenti del metodo.Data flows into your C# function via method arguments. I nomi di argomento sono specificati in un file function.json e sono disponibili nomi predefiniti per l'accesso a elementi quali il logger delle funzioni e i token di annullamento.Argument names are specified in a function.json file, and there are predefined names for accessing things like the function logger and cancellation tokens.

Il formato .csx consente di scrivere meno "boilerplate" e di concentrarsi solo sulla scrittura della funzione C#.The .csx format allows you to write less "boilerplate" and focus on writing just a C# function. Anziché eseguire il wrapping di tutti gli elementi in un spazio dei nomi e classe, definire semplicemente un metodo Run.Instead of wrapping everything in a namespace and class, just define a Run method. Includere tutti i riferimenti ad assembly e gli spazi dei nomi all'inizio del file come di consueto.Include any assembly references and namespaces at the beginning of the file as usual.

I file con estensione .csx di un'app per le funzioni vengono compilati quando viene inizializzata un'istanza.A function app's .csx files are compiled when an instance is initialized. Questo passaggio di compilazione implica che operazioni quali l'avvio a freddo potrebbero richiedere più tempo per le funzioni script C# rispetto alle librerie di classi C#.This compilation step means things like cold start may take longer for C# script functions compared to C# class libraries. Questo passaggio di compilazione è anche il motivo per cui le funzioni script C# sono modificabili nel portale di Azure, mentre le librerie di classi C# non lo sono.This compilation step is also why C# script functions are editable in the Azure Portal, while C# class libraries are not.

Associazione agli argomentiBinding to arguments

I dati di input o output sono associati a un parametro di una funzione script C# tramite la proprietà name nel file di configurazione function.json.Input or output data is bound to a C# script function parameter via the name property in the function.json configuration file. L'esempio seguente mostra un file function.json e un file run.csx per una funzione attivata dalla coda.The following example shows a function.json file and run.csx file for a queue-triggered function. Il parametro che riceve i dati dal messaggio della coda è denominato myQueueItem perché questo è il valore della proprietà 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.WindowsAzure.Storage.Queue;
using System;

public static void Run(CloudQueueMessage myQueueItem, TraceWriter log)
{
    log.Info($"C# Queue trigger function processed: {myQueueItem.AsString}");
}

L'istruzione #r è spiegata più avanti in questo articolo.The #r statement is explained later in this article.

Tipi supportati per le associazioniSupported types for bindings

Ogni associazione supporta determinati tipi. Ad esempio è possibile usare un trigger di BLOB con un parametro stringa, un parametro POCO, un parametro CloudBlockBlob o uno dei molti altri tipi supportati.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. L'articolo di riferimento sull'associazione relativo alle associazioni BLOB elenca tutti i tipi di parametri supportati per i trigger di BLOB.The binding reference article for blob bindings lists all supported parameter types for blob triggers. Per altre informazioni, vedere Trigger e associazioni e i documenti di riferimento sull'associazione per ogni tipo di associazione.For more information, see Triggers and bindings and the binding reference docs for each binding type.

Suggerimento

Se si prevede di usare binding HTTP o WebHook, evitare l'esaurimento delle porte che può essere causato da un'errata creazione di istanze di 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. Per altre informazioni, vedere l'articolo Improper Instantiation antipattern (Antipattern non valido per la creazione di istanze).For more information, review the article Improper Instantiation antipattern.

Riferimento a classi personalizzateReferencing custom classes

Se è necessario usare una classe Plain Old CLR Object (POCO) personalizzata, è possibile includere la definizione della classe all'interno dello stesso file o inserirla in un file separato.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.

Di seguito è riportato un esempio run.csx che include una definizione di 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; }
}

Una classe POCO deve avere un metodo Get e un metodo Set definiti per ogni proprietà.A POCO class must have a getter and setter defined for each property.

Riutilizzo del codice CSXReusing .csx code

È possibile usare classi e metodi definiti in altri file con estensione .csx nel file run.csx.You can use classes and methods defined in other .csx files in your run.csx file. A questo scopo, usare direttive #load nel file run.csx.To do that, use #load directives in your run.csx file. Nell'esempio seguente, una routine di registrazione denominata MyLogger viene condivisa in myLogger.csx e caricata in run.csx usando la direttiva #load:In the following example, a logging routine named MyLogger is shared in myLogger.csx and loaded into run.csx using the #load directive:

Esempio di run.csx:Example run.csx:

#load "mylogger.csx"

public static void Run(TimerInfo myTimer, TraceWriter log)
{
    log.Verbose($"Log by run.csx: {DateTime.Now}");
    MyLogger(log, $"Log by MyLogger: {DateTime.Now}");
}

Esempio di mylogger.csx:Example mylogger.csx:

public static void MyLogger(TraceWriter log, string logtext)
{
    log.Verbose(logtext);
}

L'uso di un file con estensione .csx condiviso è una prassi comune quando si vuole tipizzare fortemente i dati passati tra le funzioni usando un oggetto POCO.Using a shared .csx file is a common pattern when you want to strongly type thet data passed between functions by using a POCO object. Nell'esempio semplificato seguente, un trigger HTTP e un trigger della coda condividono un oggetto POCO denominato Order per tipizzare fortemente i dati dell'ordine:In the following simplified example, an HTTP trigger and queue trigger share a POCO object named Order to strongly type the order data:

File run.csx di esempio per il trigger HTTP:Example run.csx for HTTP trigger:

#load "..\shared\order.csx"

using System.Net;

public static async Task<HttpResponseMessage> Run(Order req, IAsyncCollector<Order> outputQueueItem, TraceWriter log)
{
    log.Info("C# HTTP trigger function received an order.");
    log.Info(req.ToString());
    log.Info("Submitting to processing queue.");

    if (req.orderId == null)
    {
        return new HttpResponseMessage(HttpStatusCode.BadRequest);
    }
    else
    {
        await outputQueueItem.AddAsync(req);
        return new HttpResponseMessage(HttpStatusCode.OK);
    }
}

File run.csx di esempio per il trigger della coda:Example run.csx for queue trigger:

#load "..\shared\order.csx"

using System;

public static void Run(Order myQueueItem, out Order outputQueueItem,TraceWriter log)
{
    log.Info($"C# Queue trigger function processed order...");
    log.Info(myQueueItem.ToString());

    outputQueueItem = myQueueItem;
}

File order.csx di esempio: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}";             
    }
}

È possibile usare un percorso relativo con la direttiva #load :You can use a relative path with the #load directive:

  • #load "mylogger.csx" carica un file che si trova nella cartella della funzione.#load "mylogger.csx" loads a file located in the function folder.
  • #load "loadedfiles\mylogger.csx" carica un file che si trova in una sottocartella della cartella della funzione.#load "loadedfiles\mylogger.csx" loads a file located in a folder in the function folder.
  • #load "..\shared\mylogger.csx" carica un file che si trova in una cartella allo stesso livello della cartella della funzione, ovvero direttamente in 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.

La direttiva #load è compatibile solo con i file con estensione .csx e non lo è con i file con estensione .cs.The #load directive works only with .csx files, not with .cs files.

Associazione al valore restituito dal metodoBinding to method return value

È possibile usare un valore restituito del metodo per un'associazione di output, usando il nome $return in function.json:You can use a method return value for an output binding, by using the name $return in function.json:

{
    "type": "queue",
    "direction": "out",
    "name": "$return",
    "queueName": "outqueue",
    "connection": "MyStorageConnectionString",
}
public static string Run(string input, TraceWriter log)
{
    return input;
}

Scrittura di più valori di outputWriting multiple output values

Per scrivere più valori in un'associazione di output, usare i tipi ICollector o IAsyncCollector .To write multiple values to an output binding, use the ICollector or IAsyncCollector types. Questi tipi sono raccolte di sola scrittura che vengono scritte nell'associazione di output durante il completamento del metodo.These types are write-only collections that are written to the output binding when the method completes.

Questo esempio scrive più messaggi in coda nella stessa coda usando ICollector:This example writes multiple queue messages into the same queue using ICollector:

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

RegistrazioneLogging

Per registrare l'output nei log in streaming in C#, includere un argomento di tipo TraceWriter.To log output to your streaming logs in C#, include an argument of type TraceWriter. È consigliabile denominarlo log.We recommend that you name it log. Evitare di usare Console.Write in Funzioni di Azure.Avoid using Console.Write in Azure Functions.

TraceWriter è definito in Azure WebJobs SDK.TraceWriter is defined in the Azure WebJobs SDK. Il livello di registrazione per TraceWriter può essere configurato in host.json.The log level for TraceWriter can be configured in host.json.

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

Nota

Per informazioni su un framework di registrazione più recente che è possibile usare al posto di TraceWriter, vedere Scrivere i log nelle funzioni C# nell'articolo Monitorare Funzioni di 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

Per rendere una funzione asincrona, usare la parola chiave async e restituire un oggetto 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);
}

Token di annullamentoCancellation tokens

Alcune operazioni richiedono l'arresto normale.Some operations require graceful shutdown. Anche se è sempre preferibile scrivere codice che possa gestire gli arresti anomali, quando si vogliono gestire le richieste di arresto definire un argomento tipizzato CancellationToken.While it's always best to write code that can handle crashing, in cases where you want to handle shutdown requests, define a CancellationToken typed argument. È fornito un CancellationToken per segnalare che viene avviato un arresto dell'host.A CancellationToken is provided to signal that a host shutdown is triggered.

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

Importazione di spazi dei nomiImporting namespaces

Se è necessario importare spazi dei nomi, è possibile farlo come al solito con la clausola using .If you need to import namespaces, you can do so as usual, with the using clause.

using System.Net;
using System.Threading.Tasks;

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

Gli spazi dei nomi seguenti vengono importati automaticamente e sono quindi facoltativi: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

Riferimento ad assembly esterniReferencing external assemblies

Per gli assembly di framework aggiungere riferimenti usando la direttiva #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;

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

Gli assembly seguenti vengono aggiunti automaticamente dall'ambiente di hosting di Funzioni di 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

È possibile fare riferimento agli assembly seguenti con il nome semplice (ad esempio, #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

Fare riferimento ad assembly personalizzatiReferencing custom assemblies

Per fare riferimento a un assembly personalizzato, è possibile usare un assembly condiviso o un assembly privato:To reference a custom assembly, you can use either a shared assembly or a private assembly:

  • Gli assembly condivisi sono condivisi da tutte le funzioni all'interno di un'app di funzione.Shared assemblies are shared across all functions within a function app. Per fare riferimento a un assembly personalizzato, caricare l'assembly nell'app di funzione, ad esempio una cartella bin nella radice dell'app per le funzioni.To reference a custom assembly, upload the assembly to your function app, such as in a bin folder in the function app root.
  • Gli assembly privati fanno parte del contesto di una funzione specificata e supportano il caricamento laterale di versioni diverse.Private assemblies are part of a given function's context, and support side-loading of different versions. Gli assembly privati devono essere caricati in una cartella bin nella directory di funzione.Private assemblies should be uploaded in a bin folder in the function directory. Fare riferimento agli assembly usando il nome del file, ad esempio #r "MyAssembly.dll".Reference the assemblies using the file name, such as #r "MyAssembly.dll".

Per informazioni su come caricare i file nella cartella della funzione, vedere la sezione sulla gestione dei pacchetti.For information on how to upload files to your function folder, see the section on package management.

Directory controllateWatched directories

La directory che contiene il file di script della funzione viene controllata automaticamente per le modifiche agli assembly.The directory that contains the function script file is automatically watched for changes to assemblies. Per controllare le modifiche agli assembly in altre directory, aggiungerle all'elenco watchDirectories in host.json.To watch for assembly changes in other directories, add them to the watchDirectories list in host.json.

Uso dei pacchetti NuGetUsing NuGet packages

Per usare i pacchetti NuGet in una funzione C#, caricare un file project.json nella cartella della funzione nel file system dell'app per le funzioni.To use NuGet packages in a C# function, upload a project.json file to the function's folder in the function app's file system. Di seguito è riportato un esempio di file project.json che aggiunge un riferimento a Microsoft.ProjectOxford.Face versione 1.1.0:Here is an example project.json file that adds a reference to Microsoft.ProjectOxford.Face version 1.1.0:

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

In Funzioni di Azure 1.x è supportato solo .NET Framework 4.6, perciò verificare che nel file project.json sia specificato net46 come illustrato qui.In Azure Functions 1.x, only the .NET Framework 4.6 is supported, so make sure that your project.json file specifies net46 as shown here.

Quando si carica un file project.json , il runtime ottiene i pacchetti e aggiunge automaticamente riferimenti agli assembly dei pacchetti.When you upload a project.json file, the runtime gets the packages and automatically adds references to the package assemblies. Non è necessario aggiungere direttive #r "AssemblyName" .You don't need to add #r "AssemblyName" directives. Per usare i tipi definiti nei pacchetti NuGet è sufficiente aggiungere le istruzioni using necessarie al file run.csx.To use the types defined in the NuGet packages; just add the required using statements to your run.csx file.

Nel runtime di Funzioni NuGet ripristina le operazioni confrontando project.json e project.lock.json.In the Functions runtime, NuGet restore works by comparing project.json and project.lock.json. Se gli indicatori di data e ora dei file non corrispondono, NuGet esegue un ripristino e aggiorna i pacchetti.If the date and time stamps of the files do not match, a NuGet restore runs and NuGet downloads updated packages. In caso contrario, NuGet non esegue alcun ripristino.However, if the date and time stamps of the files do match, NuGet does not perform a restore. Pertanto, project.lock.json non deve essere distribuito, in quanto induce NuGet a saltare il ripristino del pacchetto.Therefore, project.lock.json should not be deployed, as it causes NuGet to skip package restore. Per evitare la distribuzione del file di blocco, aggiungere project.lock.json al .gitignore file.To avoid deploying the lock file, add the project.lock.json to the .gitignore file.

Per usare un feed NuGet personalizzato, specificare il feed in un Nuget.Config nella radice dell'app per le funzioni.To use a custom NuGet feed, specify the feed in a Nuget.Config file in the Function App root. Per altre informazioni, vedere Configuring NuGet behavior (Configurazione del comportamento di NuGet).For more information, see Configuring NuGet behavior.

Uso di un file project.jsonUsing a project.json file

  1. Aprire la funzione nel portale di Azure.Open the function in the Azure portal. La scheda dei log mostra l'output di installazione del pacchetto.The logs tab displays the package installation output.
  2. Per caricare un file project.json, usare uno dei metodi descritti nella sezione Come aggiornare i file delle app per le funzioni dell'argomento Guida di riferimento per gli sviluppatori di Funzioni di Azure.To upload a project.json file, use one of the methods described in the How to update function app files in the Azure Functions developer reference topic.
  3. Dopo il caricamento del file project.json , l'output visualizzato nel log in streaming della funzione è simile all'esempio seguente:After the project.json file is uploaded, you see output like the following example in your function's streaming log:
2016-04-04T19:02:48.745 Restoring packages.
2016-04-04T19:02:48.745 Starting NuGet restore
2016-04-04T19:02:50.183 MSBuild auto-detection: using msbuild version '14.0' from 'D:\Program Files (x86)\MSBuild\14.0\bin'.
2016-04-04T19:02:50.261 Feeds used:
2016-04-04T19:02:50.261 C:\DWASFiles\Sites\facavalfunctest\LocalAppData\NuGet\Cache
2016-04-04T19:02:50.261 https://api.nuget.org/v3/index.json
2016-04-04T19:02:50.261
2016-04-04T19:02:50.511 Restoring packages for D:\home\site\wwwroot\HttpTriggerCSharp1\Project.json...
2016-04-04T19:02:52.800 Installing Newtonsoft.Json 6.0.8.
2016-04-04T19:02:52.800 Installing Microsoft.ProjectOxford.Face 1.1.0.
2016-04-04T19:02:57.095 All packages are compatible with .NETFramework,Version=v4.6.
2016-04-04T19:02:57.189
2016-04-04T19:02:57.189
2016-04-04T19:02:57.455 Packages restored.

Variabili di ambienteEnvironment variables

Per ottenere una variabile di ambiente o un valore di impostazione dell'app, usare System.Environment.GetEnvironmentVariablecome illustrato nell'esempio di codice seguente: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, TraceWriter log)
{
    log.Info($"C# Timer trigger function executed at: {DateTime.Now}");
    log.Info(GetEnvironmentVariable("AzureWebJobsStorage"));
    log.Info(GetEnvironmentVariable("WEBSITE_SITE_NAME"));
}

public static string GetEnvironmentVariable(string name)
{
    return name + ": " +
        System.Environment.GetEnvironmentVariable(name, EnvironmentVariableTarget.Process);
}

Associazione in fase di esecuzioneBinding at runtime

In C# e altri linguaggi .NET, è possibile usare un metodo di associazione imperativa anziché dichiarativa in function.json.In C# and other .NET languages, you can use an imperative binding pattern, as opposed to the declarative bindings in function.json. L'associazione imperativa è utile quando i parametri di associazione devono essere calcolati in fase di runtime invece che in fase di progettazione.Imperative binding is useful when binding parameters need to be computed at runtime rather than design time. Con questo modello è possibile associare rapidamente i dati ad associazioni di input e output supportate nel codice della funzione.With this pattern, you can bind to supported input and output bindings on-the-fly in your function code.

Definire un'associazione imperativa, come segue:Define an imperative binding as follows:

  • Non includere una voce in function.json per le associazioni imperative da eseguire.Do not include an entry in function.json for your desired imperative bindings.
  • Passare un parametro di input Binder binder o IBinder binder.Pass in an input parameter Binder binder or IBinder binder.
  • Usare il seguente modello C# per eseguire l'associazione dati.Use the following C# pattern to perform the data binding.
using (var output = await binder.BindAsync<T>(new BindingTypeAttribute(...)))
{
    ...
}

BindingTypeAttribute è l'attributo .NET che definisce l'associazione e T è un tipo di input o output supportato da quel tipo di associazione.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 non può essere un tipo di parametro out, ad esempio out JObject.T cannot be an out parameter type (such as out JObject). L'associazione di output della tabella App per dispositivi mobili, ad esempio, supporta sei tipi di output, ma è possibile usare solo ICollector o IAsyncCollector per T.For example, the Mobile Apps table output binding supports six output types, but you can only use ICollector or IAsyncCollector for T.

Esempio con un solo attributoSingle attribute example

L'esempio di codice seguente crea un associazione di output del BLOB di archiviazione con percorso del BLOB definito in fase di esecuzione, quindi scrive una stringa per il 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.

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 definisce l'associazione di input o output del BLOB di archiviazione e TextWriter è un tipo di associazione di output supportato.BlobAttribute defines the Storage blob input or output binding, and TextWriter is a supported output binding type.

Esempio con più attributiMultiple attribute example

L'esempio precedente ottiene l'impostazione dell'app per la stringa di connessione dell'account di archiviazione principale dell'app, ovvero AzureWebJobsStorage.The preceding example gets the app setting for the function app's main Storage account connection string (which is AzureWebJobsStorage). È possibile specificare un'impostazione app personalizzata da usare per l'account di archiviazione aggiungendo StorageAccountAttribute e passando la matrice di attributi in 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>(). Usare un parametro Binder e non IBinder.Use a Binder parameter, not IBinder. Ad esempio: 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!");
    }
}

Nella tabella seguente vengono elencati gli attributi .NET per ogni tipo di associazione e i pacchetti in cui sono definiti.The following table lists the .NET attributes for each binding type and the packages in which they are defined.

AssociazioneBinding AttributoAttribute Aggiungi riferimentoAdd reference
Cosmos DBCosmos DB Microsoft.Azure.WebJobs.DocumentDBAttribute #r "Microsoft.Azure.WebJobs.Extensions.CosmosDB"
Hub eventiEvent Hubs Microsoft.Azure.WebJobs.ServiceBus.EventHubAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttributeMicrosoft.Azure.WebJobs.ServiceBus.EventHubAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttribute #r "Microsoft.Azure.Jobs.ServiceBus"
App per dispositivi mobiliMobile Apps Microsoft.Azure.WebJobs.MobileTableAttribute #r "Microsoft.Azure.WebJobs.Extensions.MobileApps"
Hub di notificaNotification Hubs Microsoft.Azure.WebJobs.NotificationHubAttribute #r "Microsoft.Azure.WebJobs.Extensions.NotificationHubs"
Bus di servizioService Bus Microsoft.Azure.WebJobs.ServiceBusAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttributeMicrosoft.Azure.WebJobs.ServiceBusAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttribute #r "Microsoft.Azure.WebJobs.ServiceBus"
Coda di archiviazioneStorage queue Microsoft.Azure.WebJobs.QueueAttribute, Microsoft.Azure.WebJobs.StorageAccountAttributeMicrosoft.Azure.WebJobs.QueueAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
BLOB di archiviazioneStorage blob Microsoft.Azure.WebJobs.BlobAttribute, Microsoft.Azure.WebJobs.StorageAccountAttributeMicrosoft.Azure.WebJobs.BlobAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
Tabella di archiviazioneStorage 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"

Passaggi successiviNext steps