Informations de référence pour les développeurs C# sur Azure FunctionsAzure Functions C# developer reference

Cet article est une introduction au développement d’Azure Functions à l’aide de C# dans des bibliothèques de classes .NET.This article is an introduction to developing Azure Functions by using C# in .NET class libraries.

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 le portail Azure, consultez Informations de référence pour les développeurs de scripts C# (.csx).If you're looking for guidance on using C# in the Azure portal, see C# script (.csx) developer reference.

Cet article suppose que vous avez déjà lu les articles suivants :This article assumes that you've already read the following articles:

Versions prises en chargeSupported versions

Le runtime Azure Functions 2.x utilise .NET Core 2.2.The Azure Functions 2.x runtime uses .NET Core 2.2. Votre code de fonction peut utiliser les API .NET Core 2.2 en mettant à jour les paramètres de projet Visual Studio.Your function code can use .NET Core 2.2 APIs by updating the Visual Studio project settings. Les modèles Function n’utilisent pas par défaut .NET Core 2.2 pour éviter d’affecter négativement les clients qui n’ont pas .NET Core 2.2 installé.The Function templates do not default to .NET Core 2.2 to avoid adversely affecting customers that do not have .NET Core 2.2 installed.

Projet de bibliothèque de classes Azure FunctionsFunctions class library project

Dans Visual Studio, le modèle de projet Azure Functions crée un projet de bibliothèque de classes C# qui contient les fichiers suivants :In Visual Studio, the Azure Functions project template creates a C# class library project that contains the following files:

  • host.json : stocke les paramètres de configuration qui affectent toutes les fonctions dans le projet au cours d’une exécution locale ou dans Azure.host.json - stores configuration settings that affect all functions in the project when running locally or in Azure.
  • local.settings.json : stocke les paramètres de l’application et les chaînes de connexion utilisés au cours d’une exécution locale.local.settings.json - stores app settings and connection strings that are used when running locally. Ce fichier contient des secrets et n’est pas publié dans votre application de fonction dans Azure.This file contains secrets and isn't published to your function app in Azure. À la place, ajoutez des paramètres d’application à votre Function App.Instead, add app settings to your function app.

Lorsque vous créez le projet, une structure de dossiers qui ressemble à l’exemple suivant est générée dans le répertoire de sortie de build :When you build the project, a folder structure that looks like the following example is generated in the build output directory:

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

Ce répertoire correspond à ce qui est déployé dans votre application de fonction dans Azure.This directory is what gets deployed to your function app in Azure. Les extensions de liaison requises dans la version 2.x du runtime Azure Functions sont ajoutées au projet en tant que packages NuGet.The binding extensions required in version 2.x of the Functions runtime are added to the project as NuGet packages.

Important

Le processus de génération crée un fichier function.json pour chaque fonction.The build process creates a function.json file for each function. Ce fichier function.json n’est pas destiné à être directement modifié.This function.json file is not meant to be edited directly. Vous ne pouvez pas modifier la configuration des liaisons ni désactiver la fonction en modifiant ce fichier.You can't change binding configuration or disable the function by editing this file. Pour savoir comment désactiver une fonction, consultez le Guide pratique pour désactiver des fonctions.To learn how to disable a function, see How to disable functions.

Méthodes reconnues en tant que fonctionsMethods recognized as functions

Dans une bibliothèque de classes, une fonction est une méthode statique avec un attribut FunctionName et un attribut de déclencheur, comme illustré dans l’exemple suivant :In a class library, a function is a static method with a FunctionName and a trigger attribute, as shown in the following example:

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

L’attribut FunctionName marque une méthode comme point d’entrée de la fonction.The FunctionName attribute marks the method as a function entry point. Le nom doit être unique au sein d’un projet, commencer par une lettre et ne contenir que des lettres, des chiffres, _ et -, jusqu’à 127 caractères.The name must be unique within a project, start with a letter and only contain letters, numbers, _, and -, up to 127 characters in length. Les modèles de projets créent souvent une méthode nommée Run, mais le nom de la méthode peut être n’importe quel nom de méthode C# valide.Project templates often create a method named Run, but the method name can be any valid C# method name.

L’attribut de déclencheur spécifie le type de déclencheur et lie les données d’entrée à un paramètre de méthode.The trigger attribute specifies the trigger type and binds input data to a method parameter. L’exemple de fonction est déclenché par un message de file d’attente, qui est lui-même transmis à la méthode dans le paramètre myQueueItem.The example function is triggered by a queue message, and the queue message is passed to the method in the myQueueItem parameter.

Paramètres de signature de méthodeMethod signature parameters

La signature de méthode peut contenir des paramètres autres que ceux utilisés avec l’attribut de déclencheur.The method signature may contain parameters other than the one used with the trigger attribute. Voici quelques-uns des paramètres supplémentaires que vous pouvez inclure :Here are some of the additional parameters that you can include:

L’ordre des paramètres dans la signature de fonction n’a pas d’importance.The order of parameters in the function signature does not matter. Par exemple, vous pouvez placer les paramètres de déclencheur avant ou après les autres liaisons, de même que vous pouvez placer le paramètre de l’enregistreur d’événements avant ou après les paramètres de liaison ou de déclencheur.For example, you can put trigger parameters before or after other bindings, and you can put the logger parameter before or after trigger or binding parameters.

Exemple de liaison de sortieOutput binding example

L’exemple suivant modifie l’exemple précédent en ajoutant une liaison de file d’attente de sortie.The following example modifies the preceding one by adding an output queue binding. La fonction écrit le message de file d’attente qui déclenche la fonction vers un nouveau message de file d’attente dans une autre file d’attente.The function writes the queue message that triggers the function to a new queue message in a different queue.

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

Les articles de référence sur les liaisons (Liaisons de stockage File d’attente Azure pour Azure Functions, par exemple) décrivent les types de paramètre que vous pouvez utiliser avec les attributs de liaison de déclencheur, d’entrée ou de sortie.The binding reference articles (Storage queues, for example) explain which parameter types you can use with trigger, input, or output binding attributes.

Exemple d’expression de liaisonBinding expressions example

Le code suivant permet d’obtenir le nom de la file d’attente à surveiller à partir d’un paramètre d’application, et de récupérer l’heure de création du message de file d’attente dans le paramètre insertionTime.The following code gets the name of the queue to monitor from an app setting, and it gets the queue message creation time in the insertionTime parameter.

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

Fichier function.json généré automatiquementAutogenerated function.json

Le processus de build crée un fichier function.json dans un dossier de fonction du dossier de build.The build process creates a function.json file in a function folder in the build folder. Comme indiqué précédemment, ce fichier n’est pas destiné à être modifié directement.As noted earlier, this file is not meant to be edited directly. Vous ne pouvez pas modifier la configuration des liaisons ni désactiver la fonction en modifiant ce fichier.You can't change binding configuration or disable the function by editing this file.

L’objectif de ce fichier est de fournir au contrôleur de mise à l’échelle les informations à utiliser pour les décisions de mise à l’échelle affectant le plan de consommation.The purpose of this file is to provide information to the scale controller to use for scaling decisions on the consumption plan. C’est pourquoi le fichier ne contient pas de liaisons d’entrée ou de sortie, mais uniquement des informations de déclencheur.For this reason, the file only has trigger info, not input or output bindings.

Le fichier function.json généré inclut une propriété configurationSource qui indique au runtime d’utiliser les attributs .NET pour les liaisons, au lieu de la configuration function.json.The generated function.json file includes a configurationSource property that tells the runtime to use .NET attributes for bindings, rather than function.json configuration. Voici un exemple :Here's an example:

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

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

La génération du fichier function.json est effectuée par le package NuGet Microsoft.NET.Sdk.Functions.The function.json file generation is performed by the NuGet package Microsoft.NET.Sdk.Functions.

Le même package est utilisé pour les versions 1.x et 2.x du runtime Functions.The same package is used for both version 1.x and 2.x of the Functions runtime. Le framework cible est ce qui différencie un projet 1.x d’un projet 2.x.The target framework is what differentiates a 1.x project from a 2.x project. Voici les parties correspondantes des fichiers .csproj, qui montrent les frameworks cibles et le même package Sdk :Here are the relevant parts of .csproj files, showing different target frameworks and the same Sdk package:

Functions 1.xFunctions 1.x

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

Functions 2.xFunctions 2.x

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

Parmi les dépendances de package Sdk figurent les déclencheurs et les liaisons.Among the Sdk package dependencies are triggers and bindings. Un projet 1.x fait référence à des déclencheurs et des liaisons 1.x parce que ceux-ci ciblent le .NET Framework, alors que les déclencheurs et liaisons 2.x ciblent .NET Core.A 1.x project refers to 1.x triggers and bindings because those triggers and bindings target the .NET Framework, while 2.x triggers and bindings target .NET Core.

Le package Sdk dépend également de Newtonsoft.Json et indirectement de WindowsAzure.Storage.The Sdk package also depends on Newtonsoft.Json, and indirectly on WindowsAzure.Storage. Ces dépendances garantissent que votre projet utilise des versions de package compatibles avec la version du runtime Functions qui est ciblée par le projet.These dependencies make sure that your project uses the versions of those packages that work with the Functions runtime version that the project targets. Par exemple, Newtonsoft.Json a la version 11 pour .NET Framework 4.6.1, mais le runtime Functions qui cible .NET Framework 4.6.1 est compatible uniquement avec Newtonsoft.Json 9.0.1.For example, Newtonsoft.Json has version 11 for .NET Framework 4.6.1, but the Functions runtime that targets .NET Framework 4.6.1 is only compatible with Newtonsoft.Json 9.0.1. Par conséquent, le code de fonction de votre projet doit également utiliser Newtonsoft.Json 9.0.1.So your function code in that project also has to use Newtonsoft.Json 9.0.1.

Le code source de Microsoft.NET.Sdk.Functions est disponible dans le dépôt GitHub azure-functions-vs-build-sdk.The source code for Microsoft.NET.Sdk.Functions is available in the GitHub repo azure-functions-vs-build-sdk.

Version du runtimeRuntime version

Visual Studio utilise les outils Azure Functions Core Tools pour exécuter les projets Functions.Visual Studio uses the Azure Functions Core Tools to run Functions projects. Ils constituent l’interface de ligne de commande du runtime Functions.The Core Tools is a command-line interface for the Functions runtime.

L’installation des outils Core Tools à l’aide de npm n’affecte pas la version de Core Tools utilisée par Visual Studio.If you install the Core Tools by using npm, that doesn't affect the Core Tools version used by Visual Studio. Pour le runtime Functions version 1.x, Visual Studio stocke les versions de Core Tools dans %USERPROFILE%\AppData\Local\Azure.Functions.Cli et utilise la dernière version stockée.For the Functions runtime version 1.x, Visual Studio stores Core Tools versions in %USERPROFILE%\AppData\Local\Azure.Functions.Cli and uses the latest version stored there. Pour Functions 2.x, les outils Core Tools sont inclus dans l’extension Azure Functions and Web Jobs Tools.For Functions 2.x, the Core Tools are included in the Azure Functions and Web Jobs Tools extension. Pour les versions 1.x et 2.x, vous pouvez voir quelle version est utilisée dans la sortie de console lorsque vous exécutez un projet Functions :For both 1.x and 2.x, you can see what version is being used in the console output when you run a Functions project:

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

Types pris en charge pour les liaisonsSupported types for bindings

Chaque liaison possède ses propres types pris en charge. Par exemple, un attribut de déclencheur d’objet blob peut être appliqué à 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 attribute can be applied to 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.The binding reference article for blob bindings lists all supported parameter types. 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.

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

Vous pouvez utiliser une valeur de retour de méthode pour une liaison de sortie en appliquant l’attribut à la valeur de retour de méthode.You can use a method return value for an output binding, by applying the attribute to the method return value. 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 class ICollectorExample
{
    [FunctionName("CopyQueueMessageICollector")]
    public static void Run(
        [QueueTrigger("myqueue-items-source-3")] string myQueueItem,
        [Queue("myqueue-items-destination")] ICollector<string> myDestinationQueue,
        ILogger log)
    {
        log.LogInformation($"C# function processed: {myQueueItem}");
        myDestinationQueue.Add($"Copy 1: {myQueueItem}");
        myDestinationQueue.Add($"Copy 2: {myQueueItem}");
    }
}

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 le nom log, comme dans l’exemple suivant :We recommend that you name it log, as in the following example:

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

Évitez d’utiliser Console.Write dans Azure Functions.Avoid using Console.Write in Azure Functions. Pour plus d’informations, consultez Écrire des journaux d’activité dans des fonctions C# dans l’article Surveiller Azure Functions.For more information, 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 static class AsyncExample
{
    [FunctionName("BlobCopy")]
    public static async Task RunAsync(
        [BlobTrigger("sample-images/{blobName}")] Stream blobInput,
        [Blob("sample-images-copies/{blobName}", FileAccess.Write)] Stream blobOutput,
        CancellationToken token,
        ILogger log)
    {
        log.LogInformation($"BlobCopy function processed.");
        await blobInput.CopyToAsync(blobOutput, 4096, token);
    }
}

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.

public static class CancellationTokenExample
{
    public static void Run(
        [QueueTrigger("inputqueue")] string inputText,
        TextWriter logger,
        CancellationToken token)
    {
        for (int i = 0; i < 100; i++)
        {
            if (token.IsCancellationRequested)
            {
                logger.WriteLine("Function was cancelled at iteration {0}", i);
                break;
            }
            Thread.Sleep(5000);
            logger.WriteLine("Normal processing for queue message={0}", inputText);
        }
    }
}

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 class EnvironmentVariablesExample
{
    [FunctionName("GetEnvironmentVariables")]
    public static void Run([TimerTrigger("0 */5 * * * *")]TimerInfo myTimer, ILogger log)
    {
        log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
        log.LogInformation(GetEnvironmentVariable("AzureWebJobsStorage"));
        log.LogInformation(GetEnvironmentVariable("WEBSITE_SITE_NAME"));
    }

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

Les paramètres de l’application peuvent être lus à partir de variables d’environnement lors du développement localement et de l’exécution dans Azure.App settings can be read from environment variables both when developing locally and when running in Azure. Lors du développement localement, les paramètres de l’application proviennent de la collection Values dans le fichier local.settings.json.When developing locally, app settings come from the Values collection in the local.settings.json file. Dans les deux environnements, local et Azure, GetEnvironmentVariable("<app setting name>") récupère la valeur du paramètre d’application nommé.In both environments, local and Azure, GetEnvironmentVariable("<app setting name>") retrieves the value of the named app setting. Par exemple, lorsque vous exécutez localement, « My Site Name » est retourné si votre fichier local.settings.json contient { "Values": { "WEBSITE_SITE_NAME": "My Site Name" } }.For instance, when you're running locally, "My Site Name" would be returned if your local.settings.json file contains { "Values": { "WEBSITE_SITE_NAME": "My Site Name" } }.

La propriété System.Configuration.ConfigurationManager.AppSettings est une autre API permettant d’obtenir des valeurs de paramètre d’application, mais nous vous recommandons d’utiliser GetEnvironmentVariable comme indiqué ici.The System.Configuration.ConfigurationManager.AppSettings property is an alternative API for getting app setting values, but we recommend that you use GetEnvironmentVariable as shown here.

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 les attributs.In C# and other .NET languages, you can use an imperative binding pattern, as opposed to the declarative bindings in attributes. 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’attribut dans la signature de fonction pour les liaisons impératives souhaitées.Do not include an attribute in the function signature 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> avec des liaisons impératives.For example, the Mobile Apps table output binding supports six output types, but you can only use ICollector<T> or IAsyncCollector<T> with imperative binding.

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.

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

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

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

Déclencheurs et liaisonsTriggers and bindings

Ce tableau présente les liaisons qui sont prises en charge dans les deux versions majeures du runtime Azure Functions.This table shows the bindings that are supported in the two major versions of the Azure Functions runtime:

TypeType 1.x1.x 2.x12.x1 DéclencheurTrigger EntréeInput OutputOutput
Stockage BlobBlob storage
Cosmos DBCosmos DB
Event GridEvent Grid
Hubs d'événementsEvent Hubs
HTTP et WebhooksHTTP & webhooks
IoT HubIoT Hub
Microsoft Graph
Tableaux Excel
Microsoft Graph
Excel tables
Microsoft Graph
Fichiers OneDrive
Microsoft Graph
OneDrive files
Microsoft Graph
E-mail Outlook
Microsoft Graph
Outlook email
Microsoft Graph
événements
Microsoft Graph
events
Microsoft Graph
Jetons d’authentification
Microsoft Graph
Auth tokens
Mobile AppsMobile Apps
Notification HubsNotification Hubs
Stockage de files d’attenteQueue storage
SendGridSendGrid
Service BusService Bus
SignalRSignalR
Stockage TableTable storage
MinuteurTimer
TwilioTwilio

1 Dans le runtime de la version 2.x, toutes les liaisons à l’exception de HTTP et du minuteur doivent être inscrites.1 In the version 2.x runtime, all bindings except HTTP and Timer must be registered. Consultez Inscrire des extensions de liaison.See Register binding extensions. Toutes les liaisons 2.x prises en charge sont aussi prises en charge dans la version 3.x, sauf indication contraire.All supported 2.x bindings are also supported in the version 3.x, unless otherwise noted.

Étapes suivantesNext steps