Azure Functions C# parancsfájl (. CSX) fejlesztői referenciájaAzure Functions C# script (.csx) developer reference

Ez a cikk bevezetést mutat be a Azure Functions C# a szkript ( . CSX) használatával történő fejlesztéséhez.This article is an introduction to developing Azure Functions by using C# script (.csx).

Azure Functions támogatja C# és C# parancsfájl-programozási nyelveket támogat.Azure Functions supports C# and C# script programming languages. Ha a Visual Studio Class Library-projektben való C# használattalkapcsolatos útmutatást keres, tekintse C# meg a fejlesztői referenciát.If you're looking for guidance on using C# in a Visual Studio class library project, see C# developer reference.

Ez a cikk azt feltételezi, hogy már elolvasta a Azure functions fejlesztői útmutatót.This article assumes that you've already read the Azure Functions developers guide.

A. CSX működéseHow .csx works

A C# Azure functions parancsfájl-felülete a Azure WebJobs SDK-ra épül.The C# script experience for Azure Functions is based on the Azure WebJobs SDK. Az adatfolyamatok C# metódus argumentumai használatával áramlanak a függvénybe.Data flows into your C# function via method arguments. Az argumentumok neve egy fájlban function.json van megadva, és előre definiált nevek vannak az olyan dolgokhoz való hozzáféréshez, mint a Function Logger és a lemondási tokenek.Argument names are specified in a function.json file, and there are predefined names for accessing things like the function logger and cancellation tokens.

A . CSX formátum lehetővé teszi, hogy kevesebb "szöveggel" írjon be egy C# függvényt, és csak a függvények írására összpontosítsanak.The .csx format allows you to write less "boilerplate" and focus on writing just a C# function. A névtér és az osztály összes elemének becsomagolása helyett csak egy Run metódust adjon meg.Instead of wrapping everything in a namespace and class, just define a Run method. A szokásos módon adja meg a fájl elején található szerelvény-hivatkozásokat és névtereket.Include any assembly references and namespaces at the beginning of the file as usual.

A függvény alkalmazás . CSX fájljait a rendszer lefordítja egy példány inicializálásakor.A function app's .csx files are compiled when an instance is initialized. Ez a fordítási lépés azt jelenti, hogy az olyan dolgok C# , mint a hűtőházi C# indítás, hosszabb időt vehetnek igénybe a parancsfájl-függvények számára aThis compilation step means things like cold start may take longer for C# script functions compared to C# class libraries. Ez a fordítási lépés azt C# is indokolja, hogy a parancsfájl-függvények C# szerkeszthető legyenek a Azure Portalban, míg az osztály könyvtárai nem.This compilation step is also why C# script functions are editable in the Azure portal, while C# class libraries are not.

Mappa szerkezeteFolder structure

A C# parancsfájl-projekthez tartozó mappastruktúrát a következőhöz hasonlóan néz ki: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

Létezik egy megosztott Host. JSON fájl, amely a Function alkalmazás konfigurálására használható.There's a shared host.json file that can be used to configure the function app. Mindegyik függvényhez saját kódlap (. CSX) és kötési konfigurációs fájl (function. JSON) tartozik.Each function has its own code file (.csx) and binding configuration file (function.json).

A függvények futtatókörnyezet 2. x verziójában szükséges kötési kiterjesztések a extensions.csproj fájlban vannak meghatározva, és a bin mappában lévő tényleges függvénytárak fájljai vannak megadva.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. Helyi fejlesztés esetén regisztrálnia kell a kötési bővítményeket.When developing locally, you must register binding extensions. A Azure Portal funkcióinak fejlesztésekor ez a regisztráció történik.When developing functions in the Azure portal, this registration is done for you.

Argumentumok kötéseBinding to arguments

A bemeneti vagy kimeneti adatok egy C# script Function paraméterhez vannak kötve a name function. JSON konfigurációs fájl tulajdonsága segítségével.Input or output data is bound to a C# script function parameter via the name property in the function.json configuration file. A következő példa egy function. JSON fájlt mutat be, és a . CSX fájlt egy üzenetsor által aktivált függvényhez futtatja.The following example shows a function.json file and run.csx file for a queue-triggered function. A várólista-üzenetből érkező adatok fogadására szolgáló paraméter myQueueItem neve, mert ez a name tulajdonság értéke.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}");
}

Az #r utasítást a cikk későbbi részébenismertetjük.The #r statement is explained later in this article.

A kötések támogatott típusaiSupported types for bindings

Minden kötés saját támogatott típusokkal rendelkezik; a blob-triggerek például egy karakterlánc-paraméterrel, egy poco paraméterrel, egy CloudBlockBlob paraméterrel vagy számos más támogatott típussal is használhatók.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. A blob-kötésekhez tartozó kötési útmutató a blob-eseményindítók összes támogatott paraméter-típusát listázza.The binding reference article for blob bindings lists all supported parameter types for blob triggers. További információ: triggerek és kötések , valamint az egyes kötési típusok kötési dokumentációja.For more information, see Triggers and bindings and the binding reference docs for each binding type.

Tipp

Ha azt tervezi, használja a HTTP- vagy WebHook kötések, megtervezése elkerülése érdekében, hogy a nem megfelelő példányosítás okozhatja portfogyás 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. További információkért lásd: kezelése az Azure Functions kapcsolatok.For more information, see How to manage connections in Azure Functions.

Egyéni osztályok referenciájaReferencing custom classes

Ha egyéni egyszerű CLR-objektum (POCO) osztályt kell használnia, az osztály definícióját is megadhatja ugyanabban a fájlban, vagy egy külön fájlba helyezheti.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.

Az alábbi példa egy Run. CSX példát mutat be, amely egy poco osztály definícióját tartalmazza.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; }
}

A POCO osztálynak minden tulajdonsághoz meg kell adni egy leolvasót és egy beállító-állítót.A POCO class must have a getter and setter defined for each property.

A. CSX kód újrafelhasználásaReusing .csx code

A Run. CSX fájl más . CSX fájljaiban definiált osztályokat és metódusokat is használhat.You can use classes and methods defined in other .csx files in your run.csx file. Ehhez használja #load a Run. CSX fájlban található utasításokat.To do that, use #load directives in your run.csx file. A következő MyLogger példában egy nevű naplózási rutin van megosztva a myLogger. CSX -ben, és be kell tölteni a #load Run. CSX -be az direktíva használatával:In the following example, a logging routine named MyLogger is shared in myLogger.csx and loaded into run.csx using the #load directive:

Példa a 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}");
}

Példa mylogger. CSX:Example mylogger.csx:

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

A Shared . CSX fájl használata gyakori minta, ha a függvények között a Poco objektum használatával erősen szeretné beírni a függvényeket.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. A következő egyszerűsített példában egy http-trigger és egy várólista-trigger megoszt egy nevű Order poco-objektumot, hogy erősen írja be a megrendelési adatkészletet:In the following simplified example, an HTTP trigger and queue trigger share a POCO object named Order to strongly type the order data:

Példa a Run. CSX http-triggerre: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);
    }
}

Példa a Run. CSX for üzenetsor-triggerre: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;
}

Példa 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}";
    }
}

Relatív elérési utat is használhat a #load direktívával:You can use a relative path with the #load directive:

  • #load "mylogger.csx"betölti a Function mappában található fájlt.#load "mylogger.csx" loads a file located in the function folder.
  • #load "loadedfiles\mylogger.csx"betölt egy fájlt a függvény mappájában található mappában.#load "loadedfiles\mylogger.csx" loads a file located in a folder in the function folder.
  • #load "..\shared\mylogger.csx"egy mappában található fájlt tölt be, amely a Function mappával azonos szinten van, közvetlenül a wwwrootalatt.#load "..\shared\mylogger.csx" loads a file located in a folder at the same level as the function folder, that is, directly under wwwroot.

Az #load irányelv csak. cs fájlokkal használható . CSX -fájlokkal működik.The #load directive works only with .csx files, not with .cs files.

Kötés a metódus visszatérési értékéhezBinding to method return value

A metódus visszatérési értékét egy kimeneti kötéshez használhatja a function. JSONnevű név $return használatával.You can use a method return value for an output binding, by using the name $return in function.json. Példákat az Eseményindítók és kötésekcímű témakörben talál.For examples, see Triggers and bindings.

Csak akkor használja a visszaadott értéket, ha egy sikeres függvény végrehajtása mindig visszatérési értéket ad eredményül a kimeneti kötésnek.Use the return value only if a successful function execution always results in a return value to pass to the output binding. Ellenkező esetben használja ICollector a IAsyncCollectorvagy a beállítást, ahogy az a következő szakaszban látható.Otherwise, use ICollector or IAsyncCollector, as shown in the following section.

Több kimeneti érték írásaWriting multiple output values

Ha több értéket szeretne írni egy kimeneti kötésbe, vagy ha egy sikeres függvény meghívása nem eredményez semmit a kimeneti kötéshez, használja a vagy ICollector IAsyncCollector a típust.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. Ezek a típusok olyan írásvédett gyűjtemények, amelyek a metódus befejeződése után a kimeneti kötésbe íródnak.These types are write-only collections that are written to the output binding when the method completes.

Ez a példa több üzenetsor-üzenetet ír ugyanabba a ICollectorvárólistába a következő használatával: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!");
}

NaplózásLogging

Ha a kimenetét be szeretné jelentkezni a C#folyamatos átviteli naplókba, vegyen fel egy ILoggertípusú argumentumot.To log output to your streaming logs in C#, include an argument of type ILogger. Azt javasoljuk, hogy nevezze el log.We recommend that you name it log. Ne használja Console.Write a 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}");
}

Megjegyzés

További információ a helyett TraceWriterhasználható újabb naplózási keretrendszerről: naplók írása a C# functions szolgáltatásban a figyelő Azure functions cikkben.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.

AszinkronAsync

A függvény aszinkronműködéséhez használja a async kulcsszót, és egy Task objektumot ad vissza.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);
}

Aszinkron függvényekben out nem használhatók paraméterek.You can't use out parameters in async functions. Kimeneti kötések esetén használja helyette a függvény visszatérési értékét vagy egy gyűjtő objektumot .For output bindings, use the function return value or a collector object instead.

Visszavonási tokenekCancellation tokens

A függvények elfogadják a CancellationToken paramétert, amely lehetővé teszi, hogy az operációs rendszer értesítse a kódot, ha a függvény hamarosan leáll.A function can accept a CancellationToken parameter, which enables the operating system to notify your code when the function is about to be terminated. Ezzel az értesítéssel meggyőződhet arról, hogy a függvény váratlanul leáll olyan módon, amely inkonzisztens állapotban hagyja az adatvesztést.You can use this notification to make sure the function doesn't terminate unexpectedly in a way that leaves data in an inconsistent state.

Az alábbi példa bemutatja, hogyan ellenőrizhető a közelgő függvények leállítása.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);
    }
}

Névterek importálásaImporting namespaces

Ha névtereket kell importálnia, a szokásos módon megteheti a using záradékkal.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)

A rendszer automatikusan importálja a következő névtereket, ezért nem kötelező: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

Külső szerelvények hivatkozásaReferencing external assemblies

A keretrendszer-szerelvények esetében adja hozzá a hivatkozásokat az #r "AssemblyName" direktíva használatával.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)

A Azure Functions üzemeltetési környezet automatikusan hozzáadja a következő szerelvényeket: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

Az alábbi szerelvényeket egyszerű névvel (például #r "AssemblyName") lehet hivatkozni: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

Egyéni szerelvények referenciájaReferencing custom assemblies

Ha egyéni szerelvényre szeretne hivatkozni, használhatja a megosztott szerelvényt vagy egy privát szerelvényt:To reference a custom assembly, you can use either a shared assembly or a private assembly:

  • A megosztott szerelvények a Function alkalmazás összes funkciója között megoszthatók.Shared assemblies are shared across all functions within a function app. Egy egyéni szerelvényre való hivatkozáshoz töltse fel a szerelvényt egy bin nevű mappába a Function App Root mappában (wwwroot).To reference a custom assembly, upload the assembly to a folder named bin in your function app root folder (wwwroot).

  • A privát szerelvények egy adott függvény környezetének részét képezik, és támogatják a különböző verziók egymáshoz való betöltését.Private assemblies are part of a given function's context, and support side-loading of different versions. A magánhálózati szerelvényeket fel kell tölteni a bin függvény könyvtára egy mappájába.Private assemblies should be uploaded in a bin folder in the function directory. Hivatkozzon a szerelvényekre a fájlnév használatával, például #r "MyAssembly.dll":.Reference the assemblies using the file name, such as #r "MyAssembly.dll".

A fájlok a függvény mappájába való feltöltésével kapcsolatos további információkért lásd a csomagkezelőcímű szakaszt.For information on how to upload files to your function folder, see the section on package management.

Figyelt könyvtárakWatched directories

A függvény parancsfájlját tartalmazó könyvtár automatikusan figyeli a szerelvények módosításait.The directory that contains the function script file is automatically watched for changes to assemblies. Ha más címtárakban szeretné megtekinteni a szerelvények változásait watchDirectories , adja hozzá őket a Host. JSONfájl listájához.To watch for assembly changes in other directories, add them to the watchDirectories list in host.json.

NuGet-csomagok használataUsing NuGet packages

Ha a NuGet-csomagokat egy 2. x C# függvényben szeretné használni, töltsön fel egy function. Proj fájlt a függvény mappájába a Function alkalmazás fájlrendszerében.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. Íme egy példa function. Proj fájl, amely a Microsoft. ProjectOxford. Face Version 1.1.0-re mutató hivatkozást tartalmaz: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>

Ha egyéni NuGet-hírcsatornát szeretne használni, a függvényalkalmazás gyökérkönyvtárában található NuGet. config fájlban lévő hírcsatornát kell megadnia.To use a custom NuGet feed, specify the feed in a Nuget.Config file in the Function App root. További információ: a NuGet viselkedésének konfigurálása.For more information, see Configuring NuGet behavior.

Megjegyzés

Az 1. x C# függvények esetében a NuGet-csomagokat a function. Proj fájl helyett egy Project. JSON fájllal hivatkozunk.In 1.x C# functions, NuGet packages are referenced with a project.json file instead of a function.proj file.

1. x függvények esetén Ehelyett használjon Project. JSON fájlt.For 1.x functions, use a project.json file instead. Példa a Project. JSON fájlra:Here is an example project.json file:

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

Function. Proj fájl használataUsing a function.proj file

  1. Nyissa meg a függvényt a Azure Portalban.Open the function in the Azure portal. A naplók lap megjeleníti a csomag telepítési kimenetét.The logs tab displays the package installation output.
  2. A function. Proj fájl feltöltéséhez használja a Azure functions fejlesztői útmutatójának a Function app Files frissítése című témakörében ismertetett módszerek egyikét.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. A function. Proj fájl feltöltése után a következő példához hasonló kimenet jelenik meg a függvény streaming naplójában: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.

Környezeti változókEnvironment variables

Környezeti változó vagy Alkalmazásbeállítások értékének beszerzéséhez használja System.Environment.GetEnvironmentVariablea (z) értéket a következő példában látható módon: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);
}

Kötés futásidőbenBinding at runtime

A C# -ben és más .net-nyelveken egy kötelező kötési mintát is használhat a function. JSONfájlban található deklaratív kötések helyett.In C# and other .NET languages, you can use an imperative binding pattern, as opposed to the declarative bindings in function.json. A kényszerített kötés akkor hasznos, ha a kötési paramétereket nem a tervezési idő, hanem futásidőben kell kiszámítani.Imperative binding is useful when binding parameters need to be computed at runtime rather than design time. Ezzel a mintával a függvény kódjában a támogatott bemeneti és kimeneti kötésekhez köthető.With this pattern, you can bind to supported input and output bindings on-the-fly in your function code.

A következő módon adjon meg egy kötelező kötést:Define an imperative binding as follows:

  • Ne tartalmazzon bejegyzést a function. JSON fájlban a kívánt kényszerített kötésekhez.Do not include an entry in function.json for your desired imperative bindings.
  • Adjon meg egy bemeneti Binder binder paramétert IBinder bindervagy.Pass in an input parameter Binder binder or IBinder binder.
  • Az adatkötés C# végrehajtásához használja a következő mintát.Use the following C# pattern to perform the data binding.
using (var output = await binder.BindAsync<T>(new BindingTypeAttribute(...)))
{
    ...
}

BindingTypeAttributea a kötést definiáló .net- T attribútum, amely az adott kötési típus által támogatott bemeneti vagy kimeneti típus.BindingTypeAttribute is the .NET attribute that defines your binding and T is an input or output type that's supported by that binding type. Tnem lehet out paraméter típusa ( out JObjectpéldául).T cannot be an out parameter type (such as out JObject). Például a Mobile apps tábla kimeneti kötése hat kimeneti típusttámogat, de csak a ICollector<T > vagy IAsyncCollector<T> a esetében Thasználható.For example, the Mobile Apps table output binding supports six output types, but you can only use ICollector<T> or IAsyncCollector<T> for T.

Példa egyetlen attribútumraSingle attribute example

A következő mintakód létrehoz egy tárolási blob kimeneti kötést a futási időben definiált blob elérési úttal, majd karakterláncot ír a blobba.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!!");
    }
}

A BlobAttribute meghatározza a Storage blob bemeneti vagy kimeneti kötését, és a TextWriter egy támogatott kimeneti kötési típus.BlobAttribute defines the Storage blob input or output binding, and TextWriter is a supported output binding type.

Több attribútum – példaMultiple attribute example

Az előző példában beolvassa a Function alkalmazás fő Storage AzureWebJobsStorage-fiókjának (azaz) az alkalmazás beállítását.The preceding example gets the app setting for the function app's main Storage account connection string (which is AzureWebJobsStorage). A Storage-fiókhoz a StorageAccountAttribute hozzáadásával és az attribútum tömbbe BindAsync<T>()való átadásával adhat meg egyéni alkalmazás-beállítást.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>(). Használjon paramétert, nem IBinder. BinderUse a Binder parameter, not IBinder. Példa: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!");
    }
}

A következő táblázat felsorolja az egyes kötési típusok .NET-attribútumait, valamint azokat a csomagokat, amelyekben definiálva vannak.The following table lists the .NET attributes for each binding type and the packages in which they are defined.

KötésBinding AttribútumAttribute Hivatkozás hozzáadásaAdd 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"
Tárolási üzenetsorStorage queue Microsoft.Azure.WebJobs.QueueAttribute, Microsoft.Azure.WebJobs.StorageAccountAttributeMicrosoft.Azure.WebJobs.QueueAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
TárolóblobStorage blob Microsoft.Azure.WebJobs.BlobAttribute, Microsoft.Azure.WebJobs.StorageAccountAttributeMicrosoft.Azure.WebJobs.BlobAttribute, Microsoft.Azure.WebJobs.StorageAccountAttribute
Storage-táblaStorage 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"

További lépésekNext steps