C#-Entwicklerreferenz zu Azure FunctionsAzure Functions C# developer reference

Dieser Artikel ist eine Einführung in die Entwicklung von Azure Functions durch Verwenden von C# in .NET-Klassenbibliotheken.This article is an introduction to developing Azure Functions by using C# in .NET class libraries.

Azure Functions unterstützt die Programmiersprachen C# und C#-Skript.Azure Functions supports C# and C# script programming languages. Wenn Sie nach Anleitungen zum Verwenden von C# im Azure-Portal suchen, lesen Sie C#-Skriptentwicklerreferenz (C#-Skript, CSX) zu Azure Functions.If you're looking for guidance on using C# in the Azure portal, see C# script (.csx) developer reference.

In diesem Artikel wird davon ausgegangen, dass Sie die folgenden Artikel bereits gelesen haben:This article assumes that you've already read the following articles:

Funktionsklassenbibliotheks-ProjektFunctions class library project

In Visual Studio wird mit der Azure Functions-Projektvorlage ein C#-Klassenbibliotheksprojekt erstellt, das die folgenden Dateien enthält:In Visual Studio, the Azure Functions project template creates a C# class library project that contains the following files:

  • host.json: Speichert Konfigurationseinstellungen, die sich auf alle Funktionen im Projekt auswirken, wenn es lokal oder in Azure ausgeführt wird.host.json - stores configuration settings that affect all functions in the project when running locally or in Azure.
  • local.settings.json: Speichert App-Einstellungen und Verbindungszeichenfolgen, die verwendet werden, wenn das Projekt lokal ausgeführt wird.local.settings.json - stores app settings and connection strings that are used when running locally. Diese Datei enthält Geheimnisse und wird nicht in Ihrer Funktions-App in Azure veröffentlicht.This file contains secrets and isn't published to your function app in Azure. Gehen Sie stattdessen so vor, dass Sie Ihrer Funktions-App App-Einstellungen hinzufügen.Instead, add app settings to your function app.

Wenn Sie das Projekt erstellen, wird im Buildausgabeverzeichnis eine Ordnerstruktur generiert, die weitgehend so aussieht wie das folgende Beispiel: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

Dieses Verzeichnis wird in Ihrer Funktions-App in Azure bereitgestellt.This directory is what gets deployed to your function app in Azure. Die in Version 2.x der Functions-Runtime erforderlichen Bindungserweiterungen werden dem Projekt als NuGet-Pakete hinzugefügt.The binding extensions required in version 2.x of the Functions runtime are added to the project as NuGet packages.

Wichtig

Im Buildprozess wird für jede Funktion eine Datei vom Typ function.json erstellt.The build process creates a function.json file for each function. Die Datei function.json ist nicht für die direkte Bearbeitung vorgesehen.This function.json file is not meant to be edited directly. Sie können weder die Bindungskonfiguration ändern noch die Funktion deaktivieren, indem Sie diese Datei bearbeiten.You can't change binding configuration or disable the function by editing this file. Informationen zum Deaktivieren einer Funktion finden Sie unter Gewusst wie: Deaktivieren von Funktionen.To learn how to disable a function, see How to disable functions.

Methoden, die als Funktionen erkannt werdenMethods recognized as functions

In einer Klassenbibliothek ist eine Funktion eine statische Methode mit einem Funktionsnamen (FunctionName) und einem Trigger-Attribut, wie im folgenden Beispiel gezeigt: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}");
    }
} 

Das Attribut FunctionName kennzeichnet die Methode als Funktionseinstiegspunkt.The FunctionName attribute marks the method as a function entry point. Der Name muss innerhalb eines Projekts eindeutig sein, mit einem Buchstaben beginnen und darf nur Buchstaben, Ziffern, _ und - enthalten. Bis zu 127 Zeichen sind zulässig.The name must be unique within a project, start with a letter and only contain letters, numbers, _, and -, up to 127 characters in length. Projektvorlagen erstellen oft eine Methode namens Run, aber der Name der Methode kann ein beliebiger gültiger C#-Methodennamen sein.Project templates often create a method named Run, but the method name can be any valid C# method name.

Das Trigger-Attribut gibt den Triggertyp an und bindet die Eingabedaten an einen Methodenparameter.The trigger attribute specifies the trigger type and binds input data to a method parameter. Die Beispielfunktion wird durch eine Warteschlangennachricht ausgelöst, und die Warteschlangennachricht wird im myQueueItem-Parameter an die Methode übergeben.The example function is triggered by a queue message, and the queue message is passed to the method in the myQueueItem parameter.

MethodensignaturparameterMethod signature parameters

Die Methodensignatur kann andere Parameter als den mit dem Triggerattribut verwendeten Parameter enthalten.The method signature may contain parameters other than the one used with the trigger attribute. Hier sind einige weitere Parameter, die Sie verwenden können:Here are some of the additional parameters that you can include:

Die Reihenfolge der Parameter in der Funktionssignatur spielt keine Rolle.The order of parameters in the function signature does not matter. Beispielsweise können Sie Triggerparameter für Bindungen voran- oder nachstellen und den Parameter „logger“ vor oder nach Trigger- oder Bindungsparametern anordnen.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.

Beispiel für eine AusgabebindungOutput binding example

Im folgenden Beispiel wird das vorhergehende geändert, indem eine Ausgabewarteschlangenbindung hinzugefügt wird.The following example modifies the preceding one by adding an output queue binding. Die Funktion schreibt die Warteschlangennachricht, die die Funktion auslöst, in eine neue Warteschlangennachricht in einer anderen Warteschlange.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;
    }
}

In den Artikeln zu den Bindungsverweisen (z. B. Speicherwarteschlangen) wird erläutert, welche Parametertypen Sie mit Trigger-, Eingabe- oder Ausgabebindungsattributen verwenden können.The binding reference articles (Storage queues, for example) explain which parameter types you can use with trigger, input, or output binding attributes.

Beispiel für BindungsausdrückeBinding expressions example

Mit dem folgenden Code wird der Name der zu überwachenden Warteschlange für eine App-Einstellung abgerufen, und der Erstellungszeitpunkt der Warteschlangennachricht ist im Parameter insertionTime enthalten.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 generierte function.json-DateiAutogenerated function.json

Im Buildprozess wird eine function.json-Datei in einem Funktionsordner im Ordner für Builds erstellt.The build process creates a function.json file in a function folder in the build folder. Wie bereits erwähnt ist diese Datei nicht für die direkte Bearbeitung vorgesehen.As noted earlier, this file is not meant to be edited directly. Sie können weder die Bindungskonfiguration ändern noch die Funktion deaktivieren, indem Sie diese Datei bearbeiten.You can't change binding configuration or disable the function by editing this file.

Der Zweck dieser Datei besteht darin, Informationen für den Skalierungscontroller bereitzustellen, die dieser für Skalierungsentscheidungen hinsichtlich des Verbrauchsplans verwenden kann.The purpose of this file is to provide information to the scale controller to use for scaling decisions on the consumption plan. Aus diesem Grund hat die Datei nur Triggerinformationen und keine Eingabe- oder Ausgabebindungen.For this reason, the file only has trigger info, not input or output bindings.

Die generierte function.json-Datei enthält eine configurationSource-Eigenschaft, die der Runtime mitteilt, dass sie statt der function.json-Konfiguration die .NET Attribute für Bindungen verwenden soll.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 sehen Sie ein Beispiel: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

Die Erstellung der function.json-Datei wird mit dem NuGet-Paket Microsoft.NET.Sdk.Functions ausgeführt.The function.json file generation is performed by the NuGet package Microsoft.NET.Sdk.Functions.

Dasselbe Paket wird für die Versionen 1.x und 2.x der Functions-Runtime verwendet.The same package is used for both version 1.x and 2.x of the Functions runtime. Ein 1.x-Projekt unterscheidet sich durch das Zielframework von einem 2.x-Projekt.The target framework is what differentiates a 1.x project from a 2.x project. Hier sind die relevanten Teile von CSPROJ-Dateien, welche verschiedene Zielframeworks und dasselbe Sdk-Paket zeigen: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>

Unter den Sdk-Paketabhängigkeiten befinden sich Auslöser und Bindungen.Among the Sdk package dependencies are triggers and bindings. Ein 1.x-Projekt verweist auf 1.x-Auslöser und -Bindungen, da diese Auslöser und Bindungen für das .NET Framework ausgelegt sind, während 2.x-Auslöser und -Bindungen für .NET Core ausgelegt sind.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.

Das Sdk-Paket hängt außerdem von Newtonsoft.Json und indirekt von WindowsAzure.Storage ab.The Sdk package also depends on Newtonsoft.Json, and indirectly on WindowsAzure.Storage. Diese Abhängigkeiten stellen sicher, dass Ihr Projekt die Versionen dieser Pakete verwendet, die mit der Functions-Runtime-Version funktionieren, auf die das Projekt ausgelegt ist.These dependencies make sure that your project uses the versions of those packages that work with the Functions runtime version that the project targets. Beispiel: Newtonsoft.Json weist Version 11 für .NET Framework 4.6.1 auf, die Functions-Runtime, die auf .NET Framework 4.6.1 ausgelegt ist, ist jedoch nur mit Newtonsoft.Json 9.0.1 kompatibel.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. Daher muss Ihr Funktionscode in diesem Projekt auch Newtonsoft.Json 9.0.1 verwenden.So your function code in that project also has to use Newtonsoft.Json 9.0.1.

Der Quellcode für Microsoft.NET.Sdk.Functions ist im GitHub-Repository azure-functions-vs-build-sdk verfügbar.The source code for Microsoft.NET.Sdk.Functions is available in the GitHub repo azure-functions-vs-build-sdk.

LaufzeitversionRuntime version

Visual Studio verwendet Azure Functions Core Tools zum Ausführen von Functions-Projekten.Visual Studio uses the Azure Functions Core Tools to run Functions projects. Core Tools ist eine Befehlszeilenschnittstelle für die Functions-Runtime.The Core Tools is a command-line interface for the Functions runtime.

Wenn Sie Core Tools mithilfe von npm installieren, wirkt sich dies nicht auf die von Visual Studio verwendete Core Tools-Version aus.If you install the Core Tools by using npm, that doesn't affect the Core Tools version used by Visual Studio. Für die Functions-Runtime-Version 1.x speichert Visual Studio Core Tools-Versionen in %USERPROFILE%\AppData\Local\Azure.Functions.Cli und verwendet die aktuelle dort gespeicherte Version.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. Für Function 2.x ist Core Tools in der Erweiterung Azure Functions und WebJobs Tools enthalten.For Functions 2.x, the Core Tools are included in the Azure Functions and Web Jobs Tools extension. Sie können sowohl für 1.x als auch 2.x anzeigen, welche Version in der Konsolenausgabe verwendet wird, wenn Sie ein Functions-Projekt ausführen: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=)

Unterstützte Typen für BindungenSupported types for bindings

Jede Bindung hat ihre eigenen unterstützten Typen. Beispielsweise kann ein Blobtriggerattribut auf einen Zeichenfolgeparameter, einen POCO-Parameter, einen CloudBlockBlob-Parameter oder einen von mehreren anderen unterstützten Typen angewendet werden.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. Im Bindungsreferenzartikel für Blobbindungen sind alle unterstützten Parametertypen aufgelistet.The binding reference article for blob bindings lists all supported parameter types. Weitere Informationen hierzu finden Sie unter Trigger und Bindungen und in den Bindungsreferenzdokumenten für jeden Bindungstyp.For more information, see Triggers and bindings and the binding reference docs for each binding type.

Tipp

Wenn Sie die HTTP- oder WebHook-Bindungen verwenden möchten, vermeiden Sie die Portauslastung, die durch nicht ordnungsgemäße Instanziierung von HttpClient verursacht werden kann.If you plan to use the HTTP or WebHook bindings, plan to avoid port exhaustion that can be caused by improper instantiation of HttpClient. Weitere Informationen finden Sie unter How to manage connections in Azure Functions (Verwalten von Verbindungen in Azure Functions).For more information, see How to manage connections in Azure Functions.

Binden an den Rückgabewert einer MethodeBinding to method return value

Sie können einen Rückgabewert einer Methode für eine Ausgabebindung nutzen, indem Sie das Attribut auf den Rückgabewert einer Methode anwenden.You can use a method return value for an output binding, by applying the attribute to the method return value. Beispiele finden Sie unter Konzepte für Azure Functions-Trigger und -Bindungen.For examples, see Triggers and bindings.

Verwenden Sie den Rückgabewert nur dann, wenn eine erfolgreiche Ausführung der Funktion immer einen Rückgabewert ergibt, der an die Ausgabebindung übergeben werden soll.Use the return value only if a successful function execution always results in a return value to pass to the output binding. Verwenden Sie andernfalls, wie im folgenden Abschnitt gezeigt, ICollector oder IAsyncCollector.Otherwise, use ICollector or IAsyncCollector, as shown in the following section.

Schreiben von mehreren AusgabewertenWriting multiple output values

Verwenden Sie die Typen ICollector oder IAsyncCollector in folgenden Fällen: 1. um mehrere Werte in eine Ausgabebindung zu schreiben oder 2. wenn ein erfolgreicher Funktionsaufruf möglicherweise keinen übergebbaren Wert für die Ausgabebindung ergibt.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. Diese Typen stellen lesegeschützte Sammlungen dar, die nach Durchführung der Methode in die Ausgabebindung geschrieben werden.These types are write-only collections that are written to the output binding when the method completes.

In diesem Beispiel werden mehrere Warteschlangennachrichten mit ICollector in die gleiche Warteschlange geschrieben: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}");
    }
}

ProtokollierungLogging

Um eine Ausgabe in C# in Ihren Streamingprotokollen zu dokumentieren, fügen Sie ein Argument vom Typ ILogger ein.To log output to your streaming logs in C#, include an argument of type ILogger. Es wird empfohlen, diesen wie im folgenden Beispiel log zu nennen: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}");
    }
} 

Vermeiden Sie die Verwendung von Console.Write in Azure Functions.Avoid using Console.Write in Azure Functions. Weitere Informationen finden Sie unter Schreiben von Protokollen in C#-Funktionen im Artikel Überwachen von Azure Functions.For more information, see Write logs in C# functions in the Monitor Azure Functions article.

AsyncAsync

Um eine Funktion asynchron auszuführen, verwenden Sie das async-Schlüsselwort, und geben Sie ein Task-Objekt zurück.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);
    }
}

Sie können keine out-Parameter in asynchronen Funktionen verwenden.You can't use out parameters in async functions. Für Ausgabebindungen verwenden Sie stattdessen Funktionsrückgabewert oder Sammlerobjekt.For output bindings, use the function return value or a collector object instead.

AbbruchtokenCancellation tokens

Eine Funktion kann einen CancellationToken-Parameter annehmen, der es dem Betriebssystem ermöglicht, den Code vor dem Beenden der Funktion zu benachrichtigen.A function can accept a CancellationToken parameter, which enables the operating system to notify your code when the function is about to be terminated. Sie können diese Benachrichtigung verwenden, um sicherzustellen, dass die Funktion nicht auf eine Weise unerwartet beendet wird, die die Daten in einem inkonsistenten Zustand hinterlässt.You can use this notification to make sure the function doesn't terminate unexpectedly in a way that leaves data in an inconsistent state.

Das folgende Beispiel zeigt, wie Sie nach einer bevorstehenden Beendigung einer Funktion suchen.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);
        }
    }
}

UmgebungsvariablenEnvironment variables

Verwenden Sie System.Environment.GetEnvironmentVariablezum Abrufen einer Umgebungsvariablen oder zum Abrufen des Werts einer App-Einstellung, wie im folgenden Codebeispiel zu sehen: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-Einstellungen können sowohl beim lokalen Entwickeln als auch bei der Ausführung unter Azure aus Umgebungsvariablen gelesen werden.App settings can be read from environment variables both when developing locally and when running in Azure. Beim lokalen Entwickeln kommen App-Einstellungen aus der Values-Sammlung in der Datei local.settings.json.When developing locally, app settings come from the Values collection in the local.settings.json file. In beiden Umgebungen, lokal und Azure, ruft GetEnvironmentVariable("<app setting name>") den Wert der benannten App-Einstellung ab.In both environments, local and Azure, GetEnvironmentVariable("<app setting name>") retrieves the value of the named app setting. Bei der lokalen Ausführung würde beispielsweise „My Site Name“ zurückgegeben, wenn Ihre local.settings.json-Datei { "Values": { "WEBSITE_SITE_NAME": "My Site Name" } } enthält.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" } }.

Die Eigenschaft System.Configuration.ConfigurationManager.AppSettings ist eine alternative API zum Abrufen von Werten einer App-Einstellung, jedoch wird die hier gezeigte Verwendung von GetEnvironmentVariable empfohlen.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.

Binden zur LaufzeitBinding at runtime

In C# und anderen .NET-Sprachen können Sie ein imperatives Bindungsmuster verwenden, im Gegensatz zu den deklarativen Bindungen in Attributen.In C# and other .NET languages, you can use an imperative binding pattern, as opposed to the declarative bindings in attributes. Imperative Bindung eignet sich, wenn Bindungsparameter zur Laufzeit statt zur Entwurfszeit berechnet werden müssen.Imperative binding is useful when binding parameters need to be computed at runtime rather than design time. Mit diesem Muster ist die Bindung an unterstützte Eingabe- und Ausgabebindungen direkt im Funktionscode möglich.With this pattern, you can bind to supported input and output bindings on-the-fly in your function code.

Definieren Sie eine imperative Bindung wie folgt:Define an imperative binding as follows:

  • Schließen Sie für die gewünschten imperativen Bindungen kein Attribut in die Funktionssignatur ein.Do not include an attribute in the function signature for your desired imperative bindings.

  • Übergeben Sie den Eingabeparameter Binder binder oder IBinder binder.Pass in an input parameter Binder binder or IBinder binder.

  • Verwenden Sie das folgende C#-Muster, um die Datenbindung auszuführen.Use the following C# pattern to perform the data binding.

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

    BindingTypeAttribute ist das .NET-Attribut, das die Bindung definiert, und T ist ein Eingabe- oder Ausgabetyp, der von diesem Bindungstyp unterstützt wird.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 darf kein out-Parametertyp sein (wie etwa out JObject).T cannot be an out parameter type (such as out JObject). Die ausgehende Bindung für die Tabelle „Mobile Apps“ unterstützt z. B. sechs Ausgabetypen, Sie können aber nur ICollector oder IAsyncCollector mit imperativer Bindung verwenden.For example, the Mobile Apps table output binding supports six output types, but you can only use ICollector or IAsyncCollector with imperative binding.

Beispiel mit einem einzigen AttributSingle attribute example

Mit dem folgenden Beispielcode wird eine ausgehende Speicherblob-Bindung mit einem Blobpfad erstellt, der zur Laufzeit definiert wird. Dann wird eine Zeichenfolge in das Blob geschrieben.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 definiert die Eingabe- oder Ausgabebindung für den Speicherblob, und TextWriter ist ein unterstützter Ausgabenbindungstyp.BlobAttribute defines the Storage blob input or output binding, and TextWriter is a supported output binding type.

Beispiel mit mehreren AttributenMultiple attribute example

Im vorherigen Beispiel wird die App-Einstellung für die Verbindungszeichenfolge (AzureWebJobsStorage) des Hauptspeicherkontos der Funktions-App abgerufen.The preceding example gets the app setting for the function app's main Storage account connection string (which is AzureWebJobsStorage). Sie können eine benutzerdefinierte App-Einstellung angeben, die für das Storage-Konto verwendet werden soll, indem Sie StorageAccountAttribute hinzufügen und das Attributarray an BindAsync<T>() übergeben.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>(). Verwenden Sie einen Binder-Parameter, nicht IBinder.Use a Binder parameter, not IBinder. Beispiel: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!!");
        }
    }
}

Trigger und BindungenTriggers and bindings

Die folgende Tabelle zeigt die Bindungen, die in den beiden Hauptversionen der Azure Functions-Runtime unterstützt werden.The following 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 EingabeInput OutputOutput
Blob StorageBlob Storage
Cosmos DBCosmos DB
Event GridEvent Grid
Event HubsEvent Hubs
HTTP und WebhooksHTTP & Webhooks
Microsoft Graph
Excel-Tabellen
Microsoft Graph
Excel tables
Microsoft Graph
OneDrive-Dateien
Microsoft Graph
OneDrive files
Microsoft Graph
Outlook-E-Mail
Microsoft Graph
Outlook email
Microsoft Graph
Ereignis
Microsoft Graph
Events
Microsoft Graph
Authentifizierungstoken
Microsoft Graph
Auth tokens
Mobile AppsMobile Apps
Notification HubsNotification Hubs
Queue StorageQueue storage
SendGridSendGrid
Service BusService Bus
SignalRSignalR
TabellenspeicherungTable storage
ZeitgeberTimer
TwilioTwilio

1 In 2.x müssen alle Bindungen außer HTTP und Timer registriert sein.1 In 2.x, all bindings except HTTP and Timer must be registered. Siehe Registrieren von Bindungserweiterungen.See Register binding extensions.

Nächste SchritteNext steps