Informations de référence pour les développeurs de scripts C# (.csx) Azure FunctionsAzure Functions C# script (.csx) developer reference

Cet article est une introduction au développement d’Azure Functions à l’aide de scripts C# ( .csx).This article is an introduction to developing Azure Functions by using C# script (.csx).

Azure Functions prend en charge le langage de programmation C#, mais également le langage de script C#.Azure Functions supports C# and C# script programming languages. Pour plus d’informations sur l’utilisation de C# dans un projet de bibliothèque de classes Visual Studio, consultez les informations de référence pour les développeurs C#.If you're looking for guidance on using C# in a Visual Studio class library project, see C# developer reference.

Cet article suppose que vous avez déjà lu le Guide de développement Azure Functions.This article assumes that you've already read the Azure Functions developers guide.

Fonctionnement de .csxHow .csx works

L’expérience de scripts C# pour Azure Functions repose sur le Kit SDK Azure WebJobs.The C# script experience for Azure Functions is based on the Azure WebJobs SDK. Les données circulent dans votre fonction C# via des arguments de méthode.Data flows into your C# function via method arguments. Les noms d’argument sont spécifiés dans un fichier function.json, et il existe des noms prédéfinis pour accéder à des éléments tels que l’enregistreur de fonctions et les jetons d’annulation.Argument names are specified in a function.json file, and there are predefined names for accessing things like the function logger and cancellation tokens.

Le format .csx vous permet d’écrire de façon moins « réutilisable » et de vous concentrer uniquement sur l’écriture d’une fonction C#.The .csx format allows you to write less "boilerplate" and focus on writing just a C# function. Au lieu de tout encapsuler dans un espace de noms et une classe, définissez simplement une méthode Run.Instead of wrapping everything in a namespace and class, just define a Run method. Ajoutez les éventuels références d’assemblys et espaces de noms au début du fichier, comme d’habitude.Include any assembly references and namespaces at the beginning of the file as usual.

Les fichiers .csx d’une application de fonction sont compilés quand une instance est initialisée.A function app's .csx files are compiled when an instance is initialized. Cette étape de compilation signifie que des opérations telles qu’un démarrage à froid peuvent être plus longues à effectuer pour les fonctions de script C# par rapport aux bibliothèques de classes C#.This compilation step means things like cold start may take longer for C# script functions compared to C# class libraries. C’est également la raison pour laquelle les fonctions de script C# sont modifiables dans le portail Azure, alors que les bibliothèques de classes C# ne le sont pas.This compilation step is also why C# script functions are editable in the Azure portal, while C# class libraries are not.

Structure de dossiersFolder structure

La structure de dossiers pour un projet de script C# est similaire à la structure ci-après :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

Il existe un fichier host.json partagé que vous pouvez utiliser pour configurer l’application de fonction.There's a shared host.json file that can be used to configure the function app. Chaque fonction a son propre fichier de code (.csx) et un fichier de configuration de liaison (function.json).Each function has its own code file (.csx) and binding configuration file (function.json).

Les extensions de liaison requises dans la version 2.x du runtime Functions sont définies dans le fichier extensions.csproj, les fichiers de bibliothèque proprement dits se trouvant dans le dossier bin.The binding extensions required in version 2.x of the Functions runtime are defined in the extensions.csproj file, with the actual library files in the bin folder. Quand vous développez localement, vous devez inscrire les extensions de liaison.When developing locally, you must register binding extensions. Quand vous développez des fonctions dans le portail Azure, cet enregistrement est effectué pour vous.When developing functions in the Azure portal, this registration is done for you.

Liaison aux argumentsBinding to arguments

Les données d’entrée ou de sortie sont liées à un paramètre de fonction de script C# via la propriété name du fichier de configuration 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’exemple suivant montre un fichier function.json et un fichier run.csx pour une fonction déclenchée par une file d’attente.The following example shows a function.json file and run.csx file for a queue-triggered function. Le paramètre qui reçoit les données du message de file d’attente s’appelle myQueueItem, car il s’agit de la valeur de la propriété 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}");
}

L’instruction #r est expliquée plus loin dans cet article.The #r statement is explained later in this article.

Types pris en charge pour les liaisonsSupported types for bindings

Chaque liaison possède ses propres types pris en charge. Par exemple, un déclencheur d’objet blob peut être utilisé avec un paramètre de chaîne, un paramètre OCT, un paramètre CloudBlockBlob ou l’un des autres types pris en charge.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’article sur les références de liaison pour les liaisons d’objets blob répertorie tous les types de paramètre pris en charge pour les déclencheurs d’objet blob.The binding reference article for blob bindings lists all supported parameter types for blob triggers. Pour plus d’informations, consultez Déclencheurs et liaisons, ainsi que les documents sur les références de liaison pour chaque type de liaison.For more information, see Triggers and bindings and the binding reference docs for each binding type.

Conseil

Si vous envisagez d’utiliser les liaisons HTTP ou WebHook, prévoyez d’éviter l’épuisement du port qui peut résulter d’une instanciation incorrecte 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. Pour plus d’informations, consultez How to manage connections in Azure Functions (Comment gérer des connexions dans Azure Functions).For more information, see How to manage connections in Azure Functions.

Référencement de classes personnaliséesReferencing custom classes

Si vous souhaitez utiliser une classe d’objet CLR traditionnel (OCT) personnalisée, vous pouvez inclure la définition de classe dans le même fichier ou la placer dans un fichier distinct.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.

L’exemple de fichier run.csx suivant inclut une définition de classe OCT.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; }
}

Des méthodes getter et setter doivent être définies pour chaque propriété d’une classe OCT.A POCO class must have a getter and setter defined for each property.

Réutilisation du code .csxReusing .csx code

Vous pouvez utiliser des classes et des méthodes définies dans d’autres fichiers .csx au sein de votre fichier run.csx.You can use classes and methods defined in other .csx files in your run.csx file. Pour ce faire, utilisez les directives #load dans votre fichier run.csx.To do that, use #load directives in your run.csx file. Dans l’exemple suivant, une routine de journalisation nommée MyLogger est partagée dans myLogger.csx et chargés dans run.csx à l’aide de la directive#load :In the following example, a logging routine named MyLogger is shared in myLogger.csx and loaded into run.csx using the #load directive:

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

Exemple mylogger.csx:Example mylogger.csx:

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

L’utilisation d’un fichier .csx partagé est un cas de figure courant quand vous souhaitez typer fortement les données transmises entre les fonctions à l’aide d’un objet OCT.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. Dans l’exemple simplifié suivant, un déclencheur HTTP et un déclencheur de file d’attente partagent un objet OCT nommé Order pour typer fortement les données de commande :In the following simplified example, an HTTP trigger and queue trigger share a POCO object named Order to strongly type the order data:

Exemple avec run.csx pour un déclencheur 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);
    }
}

Exemple avec run.csx pour un déclencheur de file d’attente :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;
}

Exemple avec order.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}";
    }
}

Vous pouvez utiliser un chemin d’accès relatif avec la directive #load :You can use a relative path with the #load directive:

  • #load "mylogger.csx" charge un fichier situé dans le dossier de la fonction.#load "mylogger.csx" loads a file located in the function folder.
  • #load "loadedfiles\mylogger.csx" charge un fichier situé dans un dossier du dossier de la fonction.#load "loadedfiles\mylogger.csx" loads a file located in a folder in the function folder.
  • #load "..\shared\mylogger.csx" charge un fichier situé dans un dossier situé au même niveau que le dossier de la fonction, c’est-à-dire directement sous 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 directive #load ne fonctionne qu’avec des fichiers .csx, et non avec des fichiers .cs.The #load directive works only with .csx files, not with .cs files.

Liaison à une valeur renvoyée par la méthodeBinding to method return value

Vous pouvez utiliser une valeur renvoyée par la méthode pour une liaison de sortie, en utilisant le nom $return dans function.json.You can use a method return value for an output binding, by using the name $return in function.json. Pour obtenir des exemples, consultez Déclencheurs et liaisons.For examples, see Triggers and bindings.

Utilisez la valeur de retour seulement si une exécution réussie de la fonction aboutit toujours à une valeur de retour à passer à la liaison de sortie.Use the return value only if a successful function execution always results in a return value to pass to the output binding. Sinon, utilisez ICollector ou IAsyncCollector, comme illustré dans la section suivante.Otherwise, use ICollector or IAsyncCollector, as shown in the following section.

Écrire plusieurs valeurs de sortieWriting multiple output values

Pour écrire plusieurs valeurs dans une liaison de sortie, ou si un appel de fonction réussi n’aboutit pas nécessairement à quelque chose à passer à la liaison de sortie, utilisez les types 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. Ces types sont des collections en écriture seule, écrites dans la liaison de sortie à la fin de la méthode.These types are write-only collections that are written to the output binding when the method completes.

Cet exemple écrit plusieurs messages de file d’attente dans la même file d’attente à l’aide de 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!");
}

JournalisationLogging

Pour consigner la sortie dans vos journaux d’activité de streaming en C#, ajoutez un argument de type ILogger.To log output to your streaming logs in C#, include an argument of type ILogger. Nous vous recommandons de le nommer log.We recommend that you name it log. Évitez d’utiliser Console.Write dans Azure Functions.Avoid using Console.Write in Azure Functions.

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

Notes

Pour plus d’informations sur un framework de journalisation plus récent que vous pouvez utiliser à la place de TraceWriter, consultez Écrire des journaux d’activité dans des fonctions C# dans l’article Surveiller l’exécution des fonctions 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

Pour rendre une fonction asynchrone, utilisez le mot clé async et retournez un objet 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);
}

Vous ne pouvez pas utiliser de paramètres out dans des fonctions asynchrones.You can't use out parameters in async functions. Pour les liaisons de sortie, utilisez la valeur de retour de fonction ou un objet collecteur à la place.For output bindings, use the function return value or a collector object instead.

Jetons d’annulationCancellation tokens

Une fonction peut accepter un paramètre CancellationToken qui permet au système d’exploitation de notifier votre code quand la fonction est sur le point de se terminer.A function can accept a CancellationToken parameter, which enables the operating system to notify your code when the function is about to be terminated. Vous pouvez utiliser cette notification pour vous assurer que la fonction ne s’arrête pas de manière inattendue et laisse les données dans un état incohérent.You can use this notification to make sure the function doesn't terminate unexpectedly in a way that leaves data in an inconsistent state.

L’exemple suivant montre comment vérifier l’arrêt imminent d’une fonction.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);
    }
}

Importation des espaces de nomsImporting namespaces

Si vous avez besoin d’importer des espaces de noms, vous pouvez le faire comme vous en avez l’habitude à l’aide de la clause 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)

Les espaces de noms suivants sont automatiquement importés et sont donc facultatifs :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

Référencement des assemblys externesReferencing external assemblies

Pour les assemblys de framework, ajoutez des références à l’aide de la directive #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)

Les assemblys suivants sont ajoutés automatiquement par l’environnement hébergeant Azure Functions :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

Les assemblys suivants peuvent être référencés par nom simple (par exemple, #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

Référencer des assemblys personnalisésReferencing custom assemblies

Pour référencer un assembly personnalisé, vous pouvez utiliser soit un assembly partagé, soit un assembly privé :To reference a custom assembly, you can use either a shared assembly or a private assembly:

  • Les assemblys partagés sont communs à toutes les fonctions d’une application de fonction.Shared assemblies are shared across all functions within a function app. Pour référencer un assembly personnalisé, chargez-le dans un dossier nommé bin dans le dossier racine de votre application de fonction (wwwroot).To reference a custom assembly, upload the assembly to a folder named bin in your function app root folder (wwwroot).

  • Les assemblys privés font partie du contexte d’une fonction donnée et sont compatibles avec le chargement indépendant de versions différentes.Private assemblies are part of a given function's context, and support side-loading of different versions. Les assemblys privés doivent être chargés dans un dossier bin du répertoire de la fonction.Private assemblies should be uploaded in a bin folder in the function directory. Référencez les assemblys avec le nom de fichier, par exemple #r "MyAssembly.dll".Reference the assemblies using the file name, such as #r "MyAssembly.dll".

Pour plus d’informations sur le téléchargement de fichiers vers votre conteneur de fonctions, consultez la section sur la gestion des packages.For information on how to upload files to your function folder, see the section on package management.

Répertoires surveillésWatched directories

Le répertoire qui contient le fichier de script de la fonction est automatiquement surveillé pour détecter les modifications apportées aux assemblys.The directory that contains the function script file is automatically watched for changes to assemblies. Pour surveiller les modifications des assemblys dans d’autres répertoires, ajoutez-les à la liste watchDirectories dans host.json.To watch for assembly changes in other directories, add them to the watchDirectories list in host.json.

Utiliser des packages NuGetUsing NuGet packages

Pour utiliser des packages NuGet dans une fonction C# 2.0, chargez un fichier function.proj dans le dossier de la fonction du système de fichiers de l’application de fonction.To use NuGet packages in a 2.x C# function, upload a function.proj file to the function's folder in the function app's file system. Voici un exemple de fichier function.proj qui ajoute une référence à Microsoft.ProjectOxford.Face version 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>

Pour utiliser un flux NuGet personnalisé, spécifiez-le dans un fichier Nuget.Config à la racine de l’application de fonction.To use a custom NuGet feed, specify the feed in a Nuget.Config file in the Function App root. Pour plus d’informations, consultez la page Configurer le comportement de NuGet.For more information, see Configuring NuGet behavior.

Notes

Dans les fonctions C# 1.0, les packages NuGet sont référencés avec un fichier project.json au lieu d’un fichier function.proj.In 1.x C# functions, NuGet packages are referenced with a project.json file instead of a function.proj file.

Pour les fonctions 1.x, utilisez un fichier project.json à la place.For 1.x functions, use a project.json file instead. Voici un exemple de fichier project.json :Here is an example project.json file:

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

Utilisation d’un fichier function.projUsing a function.proj file

  1. Ouvrez la fonction sur le Portail Azure.Open the function in the Azure portal. L’onglet journaux d’activité affiche la sortie d’installation du package.The logs tab displays the package installation output.
  2. Pour charger un fichier function.json, utilisez l’une des méthodes décrites dans la section Guide pratique pour mettre à jour les fichiers d’application de fonction de la rubrique Informations de référence pour les développeurs sur Azure Functions.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. Une fois le fichier function.proj chargé, une sortie semblable à l’exemple ci-après s’affiche dans le journal de diffusion en continu de votre fonction :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.

Variables d’environnementEnvironment variables

Pour obtenir une variable d’environnement ou une valeur de paramètre d’application, utilisez System.Environment.GetEnvironmentVariable, comme illustré dans l’exemple de code suivant :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);
}

Liaison au runtimeBinding at runtime

Avec C# et d’autres langages .NET, vous pouvez utiliser un schéma de liaison impératif, par opposition aux liaisons déclaratives dans function.json.In C# and other .NET languages, you can use an imperative binding pattern, as opposed to the declarative bindings in function.json. La liaison impérative est utile lorsque les paramètres de liaison doivent être calculés au moment du runtime plutôt que lors de la conception.Imperative binding is useful when binding parameters need to be computed at runtime rather than design time. Avec ce modèle, vous pouvez effectuer une liaison à la volée avec une liaison d’entrée et de sortie prise en charge dans le code de votre fonction.With this pattern, you can bind to supported input and output bindings on-the-fly in your function code.

Définissez une liaison impérative comme suit :Define an imperative binding as follows:

  • N’incluez pas d’entrée dans function.json pour les liaisons impératives souhaitées.Do not include an entry in function.json for your desired imperative bindings.
  • Transmettez un paramètre d’entrée Binder binder ou IBinder binder.Pass in an input parameter Binder binder or IBinder binder.
  • Utilisez le modèle en C# suivant pour effectuer la liaison de données.Use the following C# pattern to perform the data binding.
using (var output = await binder.BindAsync<T>(new BindingTypeAttribute(...)))
{
    ...
}

BindingTypeAttribute est l’attribut .NET qui définit votre liaison et T est le type d’entrée ou de sortie pris en charge par ce type de liaison.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 ne peut pas être un type de paramètre out (comme out JObject).T cannot be an out parameter type (such as out JObject). Par exemple, la liaison de sortie de la table Mobile Apps prend en charge six types de sortie, mais vous pouvez utiliser uniquement ICollector<T> ou IAsyncCollector<T> pour 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.

Exemple d’attribut uniqueSingle attribute example

L’exemple de code suivant crée une liaison de sortie d’objet blob de stockage avec un chemin d’objet blob défini au moment de l’exécution, puis écrit une chaîne vers l’objet 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 définit la liaison d’entrée ou de sortie de l’objet blob de stockage, et TextWriter est un type de liaison de sortie pris en charge.BlobAttribute defines the Storage blob input or output binding, and TextWriter is a supported output binding type.

Exemple d’attributs multiplesMultiple attribute example

L’exemple précédent obtient le paramètre d’application pour la chaîne de connexion du compte de stockage principal de l’application de fonction (à savoir AzureWebJobsStorage).The preceding example gets the app setting for the function app's main Storage account connection string (which is AzureWebJobsStorage). Vous pouvez spécifier un paramètre d’application personnalisé à utiliser pour le compte de stockage en ajoutant l’attribut StorageAccountAttribute et en transmettant le tableau d’attributs dans 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>(). Utilisez un paramètre Binder, et non IBinder.Use a Binder parameter, not IBinder. Par exemple :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!");
    }
}

Le tableau suivant répertorie les attributs .NET pour chaque type de liaison et les packages dans lesquels ils sont définis.The following table lists the .NET attributes for each binding type and the packages in which they are defined.

LiaisonBinding AttributAttribute Ajouter la référenceAdd reference
Cosmos DBCosmos DB Microsoft.Azure.WebJobs.DocumentDBAttribute #r "Microsoft.Azure.WebJobs.Extensions.CosmosDB"
Event HubsEvent 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"
Notification HubsNotification 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"
File d’attente de stockageStorage queue Microsoft.Azure.WebJobs.QueueAttribute, Microsoft.Azure.WebJobs.StorageAccountAttributeMicrosoft.Azure.WebJobs.QueueAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
Objet blob de stockageStorage blob Microsoft.Azure.WebJobs.BlobAttribute, Microsoft.Azure.WebJobs.StorageAccountAttributeMicrosoft.Azure.WebJobs.BlobAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
Table de stockageStorage 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"

Étapes suivantesNext steps