C#-Skriptentwicklerreferenz (C#-Skript, CSX) zu Azure FunctionsAzure Functions C# script (.csx) developer reference

Dieser Artikel ist eine Einführung in die Entwicklung von Azure Functions mithilfe von C#-Skript (CSX).This article is an introduction to developing Azure Functions by using C# script (.csx).

Azure Functions unterstützt die Programmiersprachen C# und C#-Skript.Azure Functions supports C# and C# script programming languages. Wenn Sie Anleitungen zum Verwenden von C# in einem Visual Studio-Klassenbibliotheksprojekt suchen, sollten Sie zur C#-Entwicklerreferenz wechseln.If you're looking for guidance on using C# in a Visual Studio class library project, see C# developer reference.

In diesem Artikel wird davon ausgegangen, dass Sie das Azure Functions: Entwicklerhandbuch bereits gelesen haben.This article assumes that you've already read the Azure Functions developers guide.

Funktionsweise von CSXHow .csx works

Die C#-Skriptoberfläche für Azure Functions basiert auf dem Azure WebJobs SDK.The C# script experience for Azure Functions is based on the Azure WebJobs SDK. Daten fließen über Methodenargumente in Ihre C#-Funktion ein.Data flows into your C# function via method arguments. Argumentnamen werden in einer function.json-Datei angegeben, und es gibt vordefinierte Namen für den Zugriff auf Elemente wie die Funktionsprotokollierung und Abbruchtoken.Argument names are specified in a function.json file, and there are predefined names for accessing things like the function logger and cancellation tokens.

Dank des CSX-Formats müssen Sie weniger Textbausteine schreiben und können sich ganz auf das Schreiben einer C#-Funktion konzentrieren.The .csx format allows you to write less "boilerplate" and focus on writing just a C# function. Anstatt sämtliche Informationen in einem Namespace und einer Klasse zu umschließen, definieren Sie einfach eine Run-Methode.Instead of wrapping everything in a namespace and class, just define a Run method. Schließen Sie wie gewohnt alle Assemblyverweise und Namespaces am Anfang der Datei ein.Include any assembly references and namespaces at the beginning of the file as usual.

Die CSX-Dateien einer Funktions-App werden kompiliert, wenn eine Instanz initialisiert wird.A function app's .csx files are compiled when an instance is initialized. Dieser Kompilierungsschritt bedeutet, dass bestimmte Dinge, etwa ein Kaltstart, für C#-Skriptfunktionen im Vergleich zu C#-Klassenbibliotheken länger dauern.This compilation step means things like cold start may take longer for C# script functions compared to C# class libraries. Dieser Kompilierungsschritt ist auch der Grund, warum C#-Skriptfunktionen im Azure-Portal bearbeitet werden können, während dies für C#-Klassenbibliotheken nicht möglich ist.This compilation step is also why C# script functions are editable in the Azure portal, while C# class libraries are not.

OrdnerstrukturFolder structure

Die Ordnerstruktur für ein C#-Skriptprojekt sieht wie folgt aus:The folder structure for a C# script project looks like the following:

FunctionsProject
 | - MyFirstFunction
 | | - run.csx
 | | - function.json
 | | - function.proj
 | - MySecondFunction
 | | - run.csx
 | | - function.json
 | | - function.proj
 | - host.json
 | - extensions.csproj
 | - bin

Sie können die freigegebene Datei host.json zum Konfigurieren der Funktions-App verwenden.There's a shared host.json file that can be used to configure the function app. Jede Funktion verfügt über eine eigene Codedatei (CSX-Datei) sowie über eine eigene Bindungskonfigurationsdatei (function.json).Each function has its own code file (.csx) and binding configuration file (function.json).

Die in Version 2.x der Functions-Laufzeit erforderlichen Bindungserweiterungen sind in der Datei extensions.csproj definiert, die eigentlichen Bibliotheksdateien befinden sich im Ordner bin.The binding extensions required in version 2.x of the Functions runtime are defined in the extensions.csproj file, with the actual library files in the bin folder. Wenn Sie lokal entwickeln, müssen Sie Bindungserweiterungen registrieren.When developing locally, you must register binding extensions. Wenn Sie Funktionen im Azure-Portal entwickeln, wird diese Registrierung für Sie ausgeführt.When developing functions in the Azure portal, this registration is done for you.

Binden an ArgumenteBinding to arguments

Eingabe- oder Ausgabedaten werden über die name-Eigenschaft in der function.json-Konfigurationsdatei an dienen C#-Skriptfunktionsparameter gebunden.Input or output data is bound to a C# script function parameter via the name property in the function.json configuration file. Im folgenden Beispiel werden eine function.json-Datei und eine run.csx-Datei für eine über die Warteschlange ausgelöste Funktion veranschaulicht.The following example shows a function.json file and run.csx file for a queue-triggered function. Der Parameter, der die Daten aus der Warteschlangennachricht empfängt, hat den Namen myQueueItem, weil dies der Wert der name-Eigenschaft ist.The parameter that receives data from the queue message is named myQueueItem because that's the value of the name property.

{
    "disabled": false,
    "bindings": [
        {
            "type": "queueTrigger",
            "direction": "in",
            "name": "myQueueItem",
            "queueName": "myqueue-items",
            "connection":"MyStorageConnectionAppSetting"
        }
    ]
}
#r "Microsoft.WindowsAzure.Storage"

using Microsoft.Extensions.Logging;
using Microsoft.WindowsAzure.Storage.Queue;
using System;

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

Die #r-Anweisung ist weiter unten in diesem Artikel erläutert.The #r statement is explained later in this article.

Unterstützte Typen für BindungenSupported types for bindings

Jede Bindung hat ihre eigenen unterstützten Typen. Beispielsweise kann ein Blobtrigger mit einem Zeichenfolgeparameter, einem POCO-Parameter, einem CloudBlockBlob-Parameter oder einem von mehreren anderen unterstützten Typen verwendet werden.Each binding has its own supported types; for instance, a blob trigger can be used with a string parameter, a POCO parameter, a CloudBlockBlob parameter, or any of several other supported types. Im Bindungsreferenzartikel für Blobbindungen sind alle unterstützten Parametertypen für Blobtrigger aufgelistet.The binding reference article for blob bindings lists all supported parameter types for blob triggers. 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.

Verweisen auf benutzerdefinierte KlassenReferencing custom classes

Wenn Sie eine benutzerdefinierte POCO-Klasse (Plain Old CLR Object) verwenden müssen, können Sie die Klassendefinition in dieselbe Datei einfügen oder in eine separate Datei setzen.If you need to use a custom Plain Old CLR Object (POCO) class, you can include the class definition inside the same file or put it in a separate file.

Im folgenden Beispiel wird ein run.csx-Beispiel veranschaulicht, das eine POCO-Klassendefinition enthält.The following example shows a run.csx example that includes a POCO class definition.

public static void Run(string myBlob, out MyClass myQueueItem)
{
    log.Verbose($"C# Blob trigger function processed: {myBlob}");
    myQueueItem = new MyClass() { Id = "myid" };
}

public class MyClass
{
    public string Id { get; set; }
}

Bei einer POCO-Klasse müssen für jede Eigenschaft ein Getter und ein Setter definiert sein.A POCO class must have a getter and setter defined for each property.

Wiederverwenden von CSX-CodeReusing .csx code

Sie können in der Datei run.csx Klassen und Methoden verwenden, die in anderen CSX -Dateien definiert sind.You can use classes and methods defined in other .csx files in your run.csx file. Verwenden Sie zu diesem Zweck #load-Anweisungen in der Datei run.csx.To do that, use #load directives in your run.csx file. Im folgenden Beispiel wird die Protokollierungsroutine MyLogger in myLogger.csx freigegeben und mit der #load-Anweisung in run.csx geladen:In the following example, a logging routine named MyLogger is shared in myLogger.csx and loaded into run.csx using the #load directive:

Beispiel für run.csx:Example run.csx:

#load "mylogger.csx"

using Microsoft.Extensions.Logging;

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

Beispiel für mylogger.csx:Example mylogger.csx:

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

Die Verwendung einer freigegebenen CSX-Datei ist ein häufiges Verfahren, wenn die Daten, die über ein POCO-Objekt zwischen Funktionen übertragen werden, stark typisiert werden sollen.Using a shared .csx file is a common pattern when you want to strongly type the data passed between functions by using a POCO object. Im folgenden vereinfachten Beispiel verwenden ein HTTP-Trigger und ein Warteschlangentrigger gemeinsam das POCO-Objekt Order, um die Bestelldaten stark zu typisieren:In the following simplified example, an HTTP trigger and queue trigger share a POCO object named Order to strongly type the order data:

Beispiel: run.csx für HTTP-Trigger:Example run.csx for HTTP trigger:

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

using System.Net;
using Microsoft.Extensions.Logging;

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

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

Beispiel: run.csx für Warteschlangentrigger:Example run.csx for queue trigger:

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

using System;
using Microsoft.Extensions.Logging;

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

    outputQueueItem = myQueueItem;
}

Beispiel: order.csx:Example order.csx:

public class Order
{
    public string orderId {get; set; }
    public string custName {get; set;}
    public string custAddress {get; set;}
    public string custEmail {get; set;}
    public string cartId {get; set; }

    public override String ToString()
    {
        return "\n{\n\torderId : " + orderId +
                  "\n\tcustName : " + custName +             
                  "\n\tcustAddress : " + custAddress +             
                  "\n\tcustEmail : " + custEmail +             
                  "\n\tcartId : " + cartId + "\n}";             
    }
}

Mit der #load -Direktive können Sie einen relativen Pfad verwenden:You can use a relative path with the #load directive:

  • #load "mylogger.csx" : Lädt eine Datei, die sich im Funktionsordner befindet.#load "mylogger.csx" loads a file located in the function folder.
  • #load "loadedfiles\mylogger.csx" : Lädt eine Datei, die sich in einem Ordner im Funktionsordner befindet.#load "loadedfiles\mylogger.csx" loads a file located in a folder in the function folder.
  • #load "..\shared\mylogger.csx" : Lädt eine Datei, die sich in einem Ordner auf der gleichen Ebene befindet wie der Funktionsordner (also direkt unter wwwroot).#load "..\shared\mylogger.csx" loads a file located in a folder at the same level as the function folder, that is, directly under wwwroot.

Die #load-Direktive kann nur mit CSX-Dateien verwendet werden, nicht mit CS-Dateien.The #load directive works only with .csx files, not with .cs files.

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

Sie können für eine Ausgabebindung den Rückgabewert einer Methode verwenden, indem Sie den Namen $return in der Datei function.json verwenden.You can use a method return value for an output binding, by using the name $return in function.json. 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 void Run(ICollector<string> myQueue, ILogger log)
{
    myQueue.Add("Hello");
    myQueue.Add("World!");
}

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. Verwenden Sie hierzu am besten den Namen log.We recommend that you name it log. Vermeiden Sie die Verwendung von Console.Write in Azure Functions.Avoid using Console.Write in Azure Functions.

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

Hinweis

Informationen zu einem neueren Protokollierungsframework, das Sie anstelle von TraceWriter verwenden können, finden Sie unter Schreiben von Protokollen in C#-Funktionen im Artikel Überwachen von Azure Functions.For information about a newer logging framework that you can use instead of TraceWriter, see Write logs in C# functions in the Monitor Azure Functions article.

AsyncAsync

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 async static Task ProcessQueueMessageAsync(
        string blobName,
        Stream blobInput,
        Stream blobOutput)
{
    await blobInput.CopyToAsync(blobOutput, 4096);
}

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.

using System;
using System.IO;
using System.Threading;

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

Importieren von NamespacesImporting namespaces

Wenn Sie Namespaces importieren müssen, ist dies wie üblich über die using -Klausel möglich.If you need to import namespaces, you can do so as usual, with the using clause.

using System.Net;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

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

Die folgenden Namespaces werden automatisch importiert und sind daher optional:The following namespaces are automatically imported and are therefore optional:

  • System
  • System.Collections.Generic
  • System.IO
  • System.Linq
  • System.Net.Http
  • System.Threading.Tasks
  • Microsoft.Azure.WebJobs
  • Microsoft.Azure.WebJobs.Host

Verweise auf externe AssemblysReferencing external assemblies

Bei Frameworkassemblys können Sie Verweise über die #r "AssemblyName" -Anweisung hinzufügen.For framework assemblies, add references by using the #r "AssemblyName" directive.

#r "System.Web.Http"

using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

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

Die folgenden Assemblys werden automatisch von der Azure Functions-Hostumgebung hinzugefügt:The following assemblies are automatically added by the Azure Functions hosting environment:

  • mscorlib
  • System
  • System.Core
  • System.Xml
  • System.Net.Http
  • Microsoft.Azure.WebJobs
  • Microsoft.Azure.WebJobs.Host
  • Microsoft.Azure.WebJobs.Extensions
  • System.Web.Http
  • System.Net.Http.Formatting

Von einem einfachen Namen kann auf folgende Assemblys verwiesen (z.B. #r "AssemblyName"):The following assemblies may be referenced by simple-name (for example, #r "AssemblyName"):

  • Newtonsoft.Json
  • Microsoft.WindowsAzure.Storage
  • Microsoft.ServiceBus
  • Microsoft.AspNet.WebHooks.Receivers
  • Microsoft.AspNet.WebHooks.Common
  • Microsoft.Azure.NotificationHubs

Verweisen von benutzerdefinierten AssemblysReferencing custom assemblies

Um eine benutzerdefinierte Assembly zu verweisen, können Sie entweder eine freigegebene Assembly oder eine private Assembly verwenden:To reference a custom assembly, you can use either a shared assembly or a private assembly:

  • Freigegebene Assemblys werden für alle Funktionen innerhalb einer Funktionen-App freigegeben.Shared assemblies are shared across all functions within a function app. Um auf eine benutzerdefinierte Assembly zu verweisen, laden Sie die Assembly in einen Ordner namens bin im Stammverzeichnis der Funktions-App (wwwroot) hoch.To reference a custom assembly, upload the assembly to a folder named bin in your function app root folder (wwwroot).

  • Private Assemblys sind Bestandteil eines Kontexts einer bestimmten Funktion und unterstützen das Querladen von verschiedenen Versionen.Private assemblies are part of a given function's context, and support side-loading of different versions. Private Assemblys sollten in einen bin-Ordner im Funktionsverzeichnis hochgeladen werden.Private assemblies should be uploaded in a bin folder in the function directory. Verweisen Sie auf die Assemblys, indem Sie den Dateinamen verwenden, etwa #r "MyAssembly.dll".Reference the assemblies using the file name, such as #r "MyAssembly.dll".

Informationen zum Hochladen von Dateien in Ihren Funktionenordner finden Sie im Abschnitt zur Paketverwaltung.For information on how to upload files to your function folder, see the section on package management.

Überwachte VerzeichnisseWatched directories

Das Verzeichnis, das die Skriptdatei für die Funktion enthält, wird automatisch im Hinblick auf Änderungen an Assemblys überwacht.The directory that contains the function script file is automatically watched for changes to assemblies. Um Änderungen an Assemblys in anderen Verzeichnissen zu überwachen, fügen Sie sie der Liste watchDirectories in der Datei host.json hinzu.To watch for assembly changes in other directories, add them to the watchDirectories list in host.json.

Verwenden von NuGet-PaketenUsing NuGet packages

Um NuGet-Pakete in einer 2.x C#-Funktion zu verwenden, laden Sie die Datei function.proj in den Ordner der Funktion im Dateisystem der Funktions-App hoch.To use NuGet packages in a 2.x C# function, upload a function.proj file to the function's folder in the function app's file system. Hier sehen Sie ein Beispiel für die Datei function.proj, die einen Verweis auf Microsoft.ProjectOxford.Face (Version 1.1.0) hinzufügt:Here is an example function.proj file that adds a reference to Microsoft.ProjectOxford.Face version 1.1.0:

<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
        <TargetFramework>netstandard2.0</TargetFramework>
    </PropertyGroup>
    
    <ItemGroup>
        <PackageReference Include="Microsoft.ProjectOxford.Face" Version="1.1.0" />
    </ItemGroup>
</Project>

Um einen benutzerdefinierten NuGet-Feed zu verwenden, geben Sie den Feed in der Datei NuGet.config im Stammverzeichnis der Funktionen-App an.To use a custom NuGet feed, specify the feed in a Nuget.Config file in the Function App root. Weitere Informationen finden Sie unter Konfigurieren des NuGet-Verhaltens.For more information, see Configuring NuGet behavior.

Hinweis

In 1.x C#-Funktionen wird auf NuGet-Pakete mit einer project.json-Datei anstelle einer function.proj-Datei verwiesen.In 1.x C# functions, NuGet packages are referenced with a project.json file instead of a function.proj file.

Verwenden Sie für 1.x-Funktionen stattdessen eine project.json-Datei.For 1.x functions, use a project.json file instead. Hier folgt eine project.json-Beispieldatei:Here is an example project.json file:

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

Verwenden einer function.proj-DateiUsing a function.proj file

  1. Öffnen Sie die Funktion im Azure-Portal.Open the function in the Azure portal. Auf der Registerkarte „Protokolle“ wird die Ausgabe der Paketinstallation angezeigt.The logs tab displays the package installation output.
  2. Verwenden Sie zum Hochladen der Datei function.proj eine der Methoden, die im Abschnitt Vorgehensweise zum Aktualisieren von Funktions-App-Dateien des Themas „Azure Functions-Entwicklerreferenz“ beschrieben werden.To upload a function.proj file, use one of the methods described in the How to update function app files in the Azure Functions developer reference topic.
  3. Nach dem Hochladen der Datei .proj wird im Streamingprotokoll Ihrer Funktion in etwa folgende Ausgabe angezeigt:After the function.proj file is uploaded, you see output like the following example in your function's streaming log:
2018-12-14T22:00:48.658 [Information] Restoring packages.
2018-12-14T22:00:48.681 [Information] Starting packages restore
2018-12-14T22:00:57.064 [Information] Restoring packages for D:\local\Temp\9e814101-fe35-42aa-ada5-f8435253eb83\function.proj...
2016-04-04T19:02:50.511 Restoring packages for D:\home\site\wwwroot\HttpTriggerCSharp1\function.proj...
2018-12-14T22:01:00.844 [Information] Installing Newtonsoft.Json 10.0.2.
2018-12-14T22:01:01.041 [Information] Installing Microsoft.ProjectOxford.Common.DotNetStandard 1.0.0.
2018-12-14T22:01:01.140 [Information] Installing Microsoft.ProjectOxford.Face.DotNetStandard 1.0.0.
2018-12-14T22:01:09.799 [Information] Restore completed in 5.79 sec for D:\local\Temp\9e814101-fe35-42aa-ada5-f8435253eb83\function.proj.
2018-12-14T22:01:10.905 [Information] Packages restored.

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 void Run(TimerInfo myTimer, ILogger log)
{
    log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
    log.LogInformation(GetEnvironmentVariable("AzureWebJobsStorage"));
    log.LogInformation(GetEnvironmentVariable("WEBSITE_SITE_NAME"));
}

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

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 function.json.In C# and other .NET languages, you can use an imperative binding pattern, as opposed to the declarative bindings in function.json. 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 keinen Eintrag in function.json ein.Do not include an entry in function.json 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 für T verwenden.For example, the Mobile Apps table output binding supports six output types, but you can only use ICollector or IAsyncCollector for T.

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.

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host.Bindings.Runtime;

public static async Task Run(string input, Binder binder)
{
    using (var writer = await binder.BindAsync<TextWriter>(new BlobAttribute("samples-output/path")))
    {
        writer.Write("Hello World!!");
    }
}

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

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host.Bindings.Runtime;

public static async Task Run(string input, Binder binder)
{
    var attributes = new Attribute[]
    {    
        new BlobAttribute("samples-output/path"),
        new StorageAccountAttribute("MyStorageAccount")
    };

    using (var writer = await binder.BindAsync<TextWriter>(attributes))
    {
        writer.Write("Hello World!");
    }
}

In der folgenden Tabelle sind die .NET-Attribute für jeden Bindungstyp und die Pakete aufgelistet, in denen sie definiert sind.The following table lists the .NET attributes for each binding type and the packages in which they are defined.

BindungBinding AttributAttribute Hinzuzufügender VerweisAdd reference
Cosmos DBCosmos DB Microsoft.Azure.WebJobs.DocumentDBAttribute #r "Microsoft.Azure.WebJobs.Extensions.CosmosDB"
Event HubsEvent Hubs Microsoft.Azure.WebJobs.ServiceBus.EventHubAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttributeMicrosoft.Azure.WebJobs.ServiceBus.EventHubAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttribute #r "Microsoft.Azure.Jobs.ServiceBus"
Mobile AppsMobile Apps Microsoft.Azure.WebJobs.MobileTableAttribute #r "Microsoft.Azure.WebJobs.Extensions.MobileApps"
Notification HubsNotification Hubs Microsoft.Azure.WebJobs.NotificationHubAttribute #r "Microsoft.Azure.WebJobs.Extensions.NotificationHubs"
Service BusService Bus Microsoft.Azure.WebJobs.ServiceBusAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttributeMicrosoft.Azure.WebJobs.ServiceBusAttribute, Microsoft.Azure.WebJobs.ServiceBusAccountAttribute #r "Microsoft.Azure.WebJobs.ServiceBus"
SpeicherwarteschlangeStorage queue Microsoft.Azure.WebJobs.QueueAttribute, Microsoft.Azure.WebJobs.StorageAccountAttributeMicrosoft.Azure.WebJobs.QueueAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
SpeicherblobStorage blob Microsoft.Azure.WebJobs.BlobAttribute, Microsoft.Azure.WebJobs.StorageAccountAttributeMicrosoft.Azure.WebJobs.BlobAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
SpeichertabelleStorage table Microsoft.Azure.WebJobs.TableAttribute, Microsoft.Azure.WebJobs.StorageAccountAttributeMicrosoft.Azure.WebJobs.TableAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
TwilioTwilio Microsoft.Azure.WebJobs.TwilioSmsAttribute #r "Microsoft.Azure.WebJobs.Extensions.Twilio"

Nächste SchritteNext steps