Naslag C# informatie voor Azure functions ontwikkel aarsAzure Functions C# developer reference

Dit artikel is een inleiding tot het ontwikkelen van Azure Functions C# door gebruik te maken van de .net-klassen bibliotheken.This article is an introduction to developing Azure Functions by using C# in .NET class libraries.

Azure Functions ondersteunt C# en C# script programmeer talen.Azure Functions supports C# and C# script programming languages. Zie C# Naslag informatie voor ontwikkel aars van scripts (. CSX)als u op zoek bent naar richt lijnen voor het gebruik C# van de Azure Portal.If you're looking for guidance on using C# in the Azure portal, see C# script (.csx) developer reference.

In dit artikel wordt ervan uitgegaan dat u de volgende artikelen al hebt gelezen:This article assumes that you've already read the following articles:

Ondersteunde versiesSupported versions

In de runtime van Azure Functions 2. x wordt .NET Core 2,2 gebruikt.The Azure Functions 2.x runtime uses .NET Core 2.2. Uw functie code kan .NET Core 2,2-Api's gebruiken door de Visual Studio-project instellingen bij te werken.Your function code can use .NET Core 2.2 APIs by updating the Visual Studio project settings. De functie sjablonen worden niet standaard ingesteld op .NET Core 2,2 om te voor komen dat klanten die geen .NET Core-2,2 hebben geïnstalleerd, nadelig worden beïnvloed.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.

Class-bibliotheek project voor functiesFunctions class library project

In Visual Studio maakt de sjabloon Azure functions project een C# klassen bibliotheek project die de volgende bestanden bevat:In Visual Studio, the Azure Functions project template creates a C# class library project that contains the following files:

  • host. json : slaat configuratie-instellingen op die van invloed zijn op alle functies in het project wanneer lokaal of in azure wordt uitgevoerd.host.json - stores configuration settings that affect all functions in the project when running locally or in Azure.
  • Local. settings. json : slaat app-instellingen en verbindings reeksen op die worden gebruikt bij het lokaal uitvoeren.local.settings.json - stores app settings and connection strings that are used when running locally. Dit bestand bevat geheimen en wordt niet gepubliceerd in uw functie-app in Azure.This file contains secrets and isn't published to your function app in Azure. Voeg in plaats daarvan app-instellingen toe aan de functie-app.Instead, add app settings to your function app.

Wanneer u het project bouwt, wordt een mapstructuur die eruitziet als in het volgende voor beeld gegenereerd in de map build Uitvoermap: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

Deze map wordt geïmplementeerd in uw functie-app in Azure.This directory is what gets deployed to your function app in Azure. De binding-uitbrei dingen die zijn vereist in versie 2. x van de functions-runtime, worden toegevoegd aan het project als NuGet-pakketten.The binding extensions required in version 2.x of the Functions runtime are added to the project as NuGet packages.

Belangrijk

Het bouw proces maakt een Function. json -bestand voor elke functie.The build process creates a function.json file for each function. Deze functie. json -bestand is niet bedoeld om rechtstreeks te worden bewerkt.This function.json file is not meant to be edited directly. U kunt de bindings configuratie niet wijzigen of de functie uitschakelen door dit bestand te bewerken.You can't change binding configuration or disable the function by editing this file. Zie functies uitschakelenvoor meer informatie over het uitschakelen van een functie.To learn how to disable a function, see How to disable functions.

Methoden die worden herkend als functionsMethods recognized as functions

In een klassen bibliotheek is een functie een statische methode met een FunctionName en een trigger kenmerk, zoals wordt weer gegeven in het volgende voor beeld: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}");
    }
} 

Het kenmerk FunctionName markeert de methode als een functie-ingangs punt.The FunctionName attribute marks the method as a function entry point. De naam moet uniek zijn binnen een project, beginnen met een letter en mag alleen letters, cijfers, _ en - bevatten, Maxi maal 127 tekens lang zijn.The name must be unique within a project, start with a letter and only contain letters, numbers, _, and -, up to 127 characters in length. Project sjablonen maken vaak een methode met de naam Run, maar de naam van de methode C# kan een geldige methode naam zijn.Project templates often create a method named Run, but the method name can be any valid C# method name.

Het trigger kenmerk geeft het trigger type aan en bindt invoer gegevens aan een methode parameter.The trigger attribute specifies the trigger type and binds input data to a method parameter. De functie voor beeld wordt geactiveerd door een wachtrij bericht en het wachtrij bericht wordt door gegeven aan de methode in de para meter myQueueItem.The example function is triggered by a queue message, and the queue message is passed to the method in the myQueueItem parameter.

Methode handtekening parametersMethod signature parameters

De methode handtekening kan andere para meters bevatten dan de hand tekening die is gebruikt met het trigger kenmerk.The method signature may contain parameters other than the one used with the trigger attribute. Hier volgen enkele van de aanvullende para meters die u kunt gebruiken:Here are some of the additional parameters that you can include:

De volg orde van de para meters in de functie handtekening is hierbij niet van belang.The order of parameters in the function signature does not matter. U kunt bijvoorbeeld trigger parameters plaatsen voor of na andere bindingen en u kunt de para meter logger voor of na de trigger-of bindings parameters plaatsen.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.

Voor beeld van uitvoer bindingOutput binding example

In het volgende voor beeld wordt de vorige wijziging aangebracht door een uitvoer wachtrij binding toe te voegen.The following example modifies the preceding one by adding an output queue binding. Met de functie wordt het wachtrij bericht geschreven dat de functie activeert naar een nieuw wachtrij bericht in een andere wachtrij.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;
    }
}

De bindende referentie artikelen (opslag wachtrijen, bijvoorbeeld) geven aan welke parameter typen u kunt gebruiken met de bindings kenmerken trigger, invoer of uitvoer.The binding reference articles (Storage queues, for example) explain which parameter types you can use with trigger, input, or output binding attributes.

Voor beeld van bindings expressiesBinding expressions example

Met de volgende code wordt de naam van de wachtrij opgehaald die moet worden bewaakt vanuit een app-instelling en wordt de aanmaak tijd van het wachtrij bericht opgehaald in de para meter 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}");
    }
}

Automatisch gegenereerde functie. jsonAutogenerated function.json

Het bouw proces maakt een Function. json -bestand in een functie map in de map build.The build process creates a function.json file in a function folder in the build folder. Zoals eerder is vermeld, is dit bestand niet bedoeld om rechtstreeks te worden bewerkt.As noted earlier, this file is not meant to be edited directly. U kunt de bindings configuratie niet wijzigen of de functie uitschakelen door dit bestand te bewerken.You can't change binding configuration or disable the function by editing this file.

Het doel van dit bestand is om informatie aan de schaal controller te verstrekken die moet worden gebruikt voor het schalen van beslissingen over het verbruiks abonnement.The purpose of this file is to provide information to the scale controller to use for scaling decisions on the consumption plan. Daarom heeft het bestand alleen trigger gegevens, geen invoer-of uitvoer bindingen.For this reason, the file only has trigger info, not input or output bindings.

De gegenereerde functie. json -bestand bevat een configurationSource-eigenschap waarmee de runtime .net-kenmerken voor bindingen kan gebruiken in plaats van Function. json -configuratie.The generated function.json file includes a configurationSource property that tells the runtime to use .NET attributes for bindings, rather than function.json configuration. Hier volgt een voorbeeld: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"
}

Micro soft. NET. SDK. functionsMicrosoft.NET.Sdk.Functions

Het gegenereerde bestand Function. json wordt uitgevoerd door het NuGet -pakket micro soft @ no__t-2NET @ no__t-3Sdk @ no__t-4Functions.The function.json file generation is performed by the NuGet package Microsoft.NET.Sdk.Functions.

Hetzelfde pakket wordt gebruikt voor versie 1. x en 2. x van de functions-runtime.The same package is used for both version 1.x and 2.x of the Functions runtime. Het doel raamwerk is een onderscheid tussen een 1. x-project en een 2. x-project.The target framework is what differentiates a 1.x project from a 2.x project. Hier vindt u de relevante delen van . csproj -bestanden, met verschillende doel raamwerken en hetzelfde Sdk-pakket: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>

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

Onder de Sdk pakket afhankelijkheden zijn triggers en bindingen.Among the Sdk package dependencies are triggers and bindings. Een 1. x-project verwijst naar 1. x-triggers en-bindingen, omdat de triggers en bindingen het .NET Framework doel hebben, terwijl 2. x-triggers en-bindingen .NET core hebben.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.

Het Sdk-pakket is ook afhankelijk van Newton soft. jsonen indirect op WindowsAzure. Storage.The Sdk package also depends on Newtonsoft.Json, and indirectly on WindowsAzure.Storage. Deze afhankelijkheden zorgen ervoor dat uw project gebruikmaakt van de versies van de pakketten die werken met de runtime versie van functions die het project doel heeft.These dependencies make sure that your project uses the versions of those packages that work with the Functions runtime version that the project targets. @No__t-0 heeft bijvoorbeeld versie 11 voor .NET Framework 4.6.1, maar de functions-runtime die is gericht op .NET Framework 4.6.1 is alleen compatibel met 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. De functie code in dat project moet dus ook Newtonsoft.Json 9.0.1 gebruiken.So your function code in that project also has to use Newtonsoft.Json 9.0.1.

De bron code voor Microsoft.NET.Sdk.Functions is beschikbaar in de GitHub opslag plaats Azure @ no__t-2FUNCTIONS @ no__t-3vs @ no__t-4build @ no__t-5sdk.The source code for Microsoft.NET.Sdk.Functions is available in the GitHub repo azure-functions-vs-build-sdk.

Runtime versieRuntime version

Visual Studio maakt gebruik van de Azure functions core tools om functies projecten uit te voeren.Visual Studio uses the Azure Functions Core Tools to run Functions projects. De belangrijkste Hulpprogram Ma's is een opdracht regel interface voor de functions-runtime.The Core Tools is a command-line interface for the Functions runtime.

Als u de basis Hulpprogramma's installeert met behulp van NPM, is dit niet van invloed op de kern Hulpprogramma's versie die wordt gebruikt door Visual Studio.If you install the Core Tools by using npm, that doesn't affect the Core Tools version used by Visual Studio. Voor de functions runtime versie 1. x slaat Visual Studio versies van kern Hulpprogramma's op in %userprofile%\AppData\Local\Azure.functions.cli en maakt gebruik van de meest recente versie die daar is opgeslagen.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. Voor functies 2. x zijn de kern Hulpprogramma's opgenomen in de uitbrei ding Azure functions en webjobs .For Functions 2.x, the Core Tools are included in the Azure Functions and Web Jobs Tools extension. Voor beide 1. x en 2. x kunt u zien welke versie wordt gebruikt in de console-uitvoer wanneer u een functions-project uitvoert: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=)

Ondersteunde typen voor bindingenSupported types for bindings

Elke binding heeft zijn eigen ondersteunde typen. een BLOB-trigger kenmerk kan bijvoorbeeld worden toegepast op een teken reeks parameter, een POCO-para meter, een CloudBlockBlob-para meter of een van de andere ondersteunde typen.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. Het referentie-artikel voor bindingen voor BLOB-bindingen bevat een lijst met alle ondersteunde parameter typen.The binding reference article for blob bindings lists all supported parameter types. Zie voor meer informatie Triggers en bindingen en de verwijzings documenten voor bindingen voor elk bindings type.For more information, see Triggers and bindings and the binding reference docs for each binding type.

Tip

Als u van plan bent te gebruiken van de HTTP- of WebHook-bindingen van plan bent om te voorkomen dat poortuitputting die kan worden veroorzaakt door onjuiste instantiëring van 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. Zie voor meer informatie, over het beheren van verbindingen in Azure Functions.For more information, see How to manage connections in Azure Functions.

Binding met retour waarde van methodeBinding to method return value

U kunt de retour waarde van een methode voor een uitvoer binding gebruiken door het kenmerk toe te passen op de retour waarde van de methode.You can use a method return value for an output binding, by applying the attribute to the method return value. Zie Triggers en bindingenvoor voor beelden.For examples, see Triggers and bindings.

Gebruik de retour waarde alleen als de uitvoering van een geslaagde functie altijd resulteert in een retour waarde die aan de uitvoer binding moet worden door gegeven.Use the return value only if a successful function execution always results in a return value to pass to the output binding. Gebruik anders ICollector of IAsyncCollector, zoals wordt weer gegeven in de volgende sectie.Otherwise, use ICollector or IAsyncCollector, as shown in the following section.

Meerdere uitvoer waarden schrijvenWriting multiple output values

Als u meerdere waarden naar een uitvoer binding wilt schrijven, of als het aanroepen van een geslaagde functie ertoe kan leiden dat er niets kan worden door gegeven aan de uitvoer binding, gebruikt u de ICollector- of @no__t 3- typen.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. Deze typen zijn alleen-schrijven verzamelingen die naar de uitvoer binding worden geschreven wanneer de methode is voltooid.These types are write-only collections that are written to the output binding when the method completes.

In dit voor beeld worden meerdere wachtrij berichten naar dezelfde wachtrij geschreven met 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}");
    }
}

LogboekregistratieLogging

Als u de uitvoer wilt registreren in C#uw streaming-logboeken, neemt u een argument van het type ILoggerop.To log output to your streaming logs in C#, include an argument of type ILogger. U wordt aangeraden deze naam te log, zoals in het volgende voor beeld: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}");
    }
} 

Vermijd het gebruik van Console.Write in Azure Functions.Avoid using Console.Write in Azure Functions. Zie Logboeken schrijven in C# functies in het artikel monitor Azure functions voor meer informatie.For more information, see Write logs in C# functions in the Monitor Azure Functions article.

AsynchroonAsync

Als u een functie asynchroonwilt maken, gebruikt u het sleutel woord async en retourneert u een Task-object.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);
    }
}

U kunt de para meters out niet gebruiken in async-functies.You can't use out parameters in async functions. Voor uitvoer bindingen gebruikt u in plaats daarvan de functie retour waarde of een Collector-object .For output bindings, use the function return value or a collector object instead.

Annulerings tokensCancellation tokens

Een functie kan een CancellationToken -para meter accepteren, waardoor het besturings systeem uw code op de hoogte stelt wanneer de functie wordt beëindigd.A function can accept a CancellationToken parameter, which enables the operating system to notify your code when the function is about to be terminated. U kunt deze melding gebruiken om ervoor te zorgen dat de functie niet onverwacht wordt beëindigd op een manier die gegevens in een inconsistente status laat.You can use this notification to make sure the function doesn't terminate unexpectedly in a way that leaves data in an inconsistent state.

In het volgende voor beeld ziet u hoe u kunt controleren op verdere beëindiging van de functie.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);
        }
    }
}

OmgevingsvariabelenEnvironment variables

Als u een omgevings variabele of een instellings waarde voor een app wilt ophalen, gebruikt u System.Environment.GetEnvironmentVariable, zoals wordt weer gegeven in het volgende code voorbeeld: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);
    }
}

App-instellingen kunnen worden gelezen van omgevings variabelen bij het lokaal ontwikkelen en wanneer ze worden uitgevoerd in Azure.App settings can be read from environment variables both when developing locally and when running in Azure. Bij het ontwikkelen van lokaal, zijn de app-instellingen afkomstig uit de verzameling Values in het bestand Local. settings. json .When developing locally, app settings come from the Values collection in the local.settings.json file. In beide omgevingen, lokaal en Azure, wordt met GetEnvironmentVariable("<app setting name>") de waarde opgehaald van de app-instelling met de naam.In both environments, local and Azure, GetEnvironmentVariable("<app setting name>") retrieves the value of the named app setting. Wanneer u bijvoorbeeld lokaal uitvoert, wordt ' mijn site naam ' geretourneerd als uw lokale. settings. json -bestand { "Values": { "WEBSITE_SITE_NAME": "My Site Name" } } bevat.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" } }.

De eigenschap System. Configuration. ConfigurationManager. AppSettings is een alternatieve API voor het ophalen van waarden voor app-instellingen, maar we raden u aan GetEnvironmentVariable te gebruiken, zoals hier wordt weer gegeven.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.

Binding tijdens runtimeBinding at runtime

In C# en andere .net-talen kunt u een dwingend bindings patroon gebruiken, in plaats van de declaratieve bindingen in kenmerken.In C# and other .NET languages, you can use an imperative binding pattern, as opposed to the declarative bindings in attributes. Dwingende binding is handig wanneer bindings parameters tijdens runtime moeten worden berekend in plaats van ontwerp tijd.Imperative binding is useful when binding parameters need to be computed at runtime rather than design time. Met dit patroon kunt u verbinding maken met ondersteunde invoer-en uitvoer bindingen die onderweg zijn in uw functie code.With this pattern, you can bind to supported input and output bindings on-the-fly in your function code.

Definieer als volgt een dwingende binding:Define an imperative binding as follows:

  • Neem in de hand tekening van de functie geen kenmerk op voor de gewenste dwingende bindingen.Do not include an attribute in the function signature for your desired imperative bindings.

  • Geef een invoer parameter Binder binder of IBinder binderdoor.Pass in an input parameter Binder binder or IBinder binder.

  • Gebruik het volgende C# patroon om de gegevens binding uit te voeren.Use the following C# pattern to perform the data binding.

    using (var output = await binder.BindAsync<T>(new BindingTypeAttribute(...)))
    {
        ...
    }
    

    BindingTypeAttribute is het .NET-kenmerk dat uw binding definieert en T is een invoer-of uitvoer type dat wordt ondersteund door dat bindings type.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 kan geen para meter van het type out zijn (zoals out JObject).T cannot be an out parameter type (such as out JObject). De Mobile Apps tabel uitvoer binding ondersteunt bijvoorbeeld zes uitvoer typen, maar u kunt alleen ICollector @ no__t-2T > of IAsyncCollector @ no__t-4T > gebruiken met dwingende binding.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.

Voor beeld van één kenmerkSingle attribute example

Met de volgende voorbeeld code wordt een opslag-BLOB-uitvoer binding gemaakt met een BLOB-pad dat tijdens runtime is gedefinieerd, waarna een teken reeks naar de BLOB wordt geschreven.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 definieert de invoer-of uitvoer binding van de opslag-BLOB en TextWriter is een ondersteund type uitvoer binding.BlobAttribute defines the Storage blob input or output binding, and TextWriter is a supported output binding type.

Voor beeld van meerdere kenmerkenMultiple attribute example

In het vorige voor beeld wordt de app-instelling voor het hoofd-opslag account van de functie-app opgehaald connection string (AzureWebJobsStorage).The preceding example gets the app setting for the function app's main Storage account connection string (which is AzureWebJobsStorage). U kunt een aangepaste app-instelling opgeven die moet worden gebruikt voor het opslag account door de StorageAccountAttribute toe te voegen en de kenmerk matrix door te geven aan 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>(). Gebruik de para meter Binder, niet IBinder.Use a Binder parameter, not IBinder. Bijvoorbeeld: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!!");
        }
    }
}

Triggers en bindingenTriggers and bindings

In deze tabel ziet u de bindingen die worden ondersteund in de twee belangrijkste versies van de Azure Functions runtime: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 TriggerTrigger InvoerInput OutputOutput
Blob StorageBlob storage
Cosmos DBCosmos DB
Event GridEvent Grid
Event HubsEvent Hubs
HTTP-& webhooksHTTP & webhooks
IoT HubIoT Hub
Microsoft Graph
Excel-tabellen
Microsoft Graph
Excel tables
Microsoft Graph
OneDrive-bestanden
Microsoft Graph
OneDrive files
Outlook
-e-mail Microsoft Graph
Microsoft Graph
Outlook email
Microsoft Graph
gebeurtenissen
Microsoft Graph
events
Microsoft Graph
auth-tokens
Microsoft Graph
Auth tokens
Mobile AppsMobile Apps
Notification HubsNotification Hubs
Queue StorageQueue storage
SendGridSendGrid
Service BusService Bus
SignalRSignalR
Table StorageTable storage
TimerTimer
TwilioTwilio

1 in 2. x moeten alle bindingen behalve http en timer worden geregistreerd.1 In 2.x, all bindings except HTTP and Timer must be registered. Zie bindings uitbreidingen registreren.See Register binding extensions.

Volgende stappenNext steps