Azure Functions C# fejlesztői dokumentációAzure Functions C# developer reference

Ez a cikk bevezetést mutat be a .NET C# -es kódtárak használatával történő Azure functions fejlesztéséhez.This article is an introduction to developing Azure Functions by using C# in .NET class libraries.

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 Azure Portal használatával C# kapcsolatos útmutatást keres, tekintse C# meg a script (. CSX) fejlesztői referenciáját.If you're looking for guidance on using C# in the Azure portal, see C# script (.csx) developer reference.

Ez a cikk azt feltételezi, hogy már elolvasta a következő cikkeket:This article assumes that you've already read the following articles:

Functions Class Library-projektFunctions class library project

A Visual Studióban a Azure functions Project sablon egy olyan C# osztály-függvénytár-projektet hoz létre, amely a következő fájlokat tartalmazza:In Visual Studio, the Azure Functions project template creates a C# class library project that contains the following files:

A projekt létrehozásakor a következő példához hasonló mappastruktúrát jön létre a Build kimeneti könyvtárában: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

Ez a könyvtár az Azure-beli Function alkalmazás üzembe helyezése.This directory is what gets deployed to your function app in Azure. A functions futtatókörnyezet 2. x verziójában szükséges kötési bővítmények a projekthez NuGet csomagokkéntlesznek hozzáadva.The binding extensions required in version 2.x of the Functions runtime are added to the project as NuGet packages.

Fontos

A build folyamat minden függvényhez létrehoz egy function. JSON fájlt.The build process creates a function.json file for each function. A function. JSON fájlt nem közvetlenül kell szerkeszteni.This function.json file is not meant to be edited directly. Nem módosíthatja a kötési konfigurációt, vagy letilthatja a függvényt a fájl szerkesztésével.You can't change binding configuration or disable the function by editing this file. A függvények letiltásával kapcsolatos további információkért lásd a függvényekletiltását ismertető témakört.To learn how to disable a function, see How to disable functions.

Függvényekként felismert metódusokMethods recognized as functions

Egy osztály-függvénytárban a függvény egy statikus metódus FunctionName a és egy trigger attribútummal, az alábbi példában látható módon: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}");
    }
} 

Az FunctionName attribútum a metódust függvény belépési pontként jelöli.The FunctionName attribute marks the method as a function entry point. A névnek egyedinek kell lennie a projekten belül, betűvel kell kezdődnie, és csak betűket, -számokat, _és, legfeljebb 127 karaktert tartalmazhat.The name must be unique within a project, start with a letter and only contain letters, numbers, _, and -, up to 127 characters in length. A Project templates gyakran létrehoz egy Runnevű metódust, de a metódus neve lehet C# bármely érvényes metódus neve.Project templates often create a method named Run, but the method name can be any valid C# method name.

Az trigger attribútum meghatározza az trigger típusát, és a bemeneti adatokat egy metódus paraméteréhez köti.The trigger attribute specifies the trigger type and binds input data to a method parameter. A példa függvényt egy üzenetsor-üzenet indítja el, és a várólista- myQueueItem üzenet a paraméterben megadott metódusnak lesz átadva.The example function is triggered by a queue message, and the queue message is passed to the method in the myQueueItem parameter.

Metódus-aláírás paramétereiMethod signature parameters

A metódus aláírása nem az trigger attribútummal használt paramétereket tartalmazhat.The method signature may contain parameters other than the one used with the trigger attribute. Íme néhány további paraméter, amelyet felvehet:Here are some of the additional parameters that you can include:

A függvények aláírásában szereplő paraméterek sorrendje nem számít.The order of parameters in the function signature does not matter. Például az aktiválási paramétereket más kötések előtt vagy után is elhelyezheti, és a naplózó paramétert trigger vagy kötési paraméterek előtt vagy után is elhelyezheti.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.

Kimeneti kötési példaOutput binding example

A következő példa egy kimeneti várólista-kötés hozzáadásával módosítja az előzőt.The following example modifies the preceding one by adding an output queue binding. A függvény az üzenetsor-üzenetet írja, amely egy másik várólistában lévő új üzenetsor-üzenetre indítja a függvényt.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;
    }
}

A kötési útmutató cikkei (például atárolási várólisták) megmutatják, hogy milyen típusú paramétereket használhat trigger-, bemeneti vagy kimeneti kötési attribútumokkal.The binding reference articles (Storage queues, for example) explain which parameter types you can use with trigger, input, or output binding attributes.

Példa kötési kifejezésekreBinding expressions example

A következő kód beolvassa az Alkalmazásbeállítások által figyelt várólista nevét, és az üzenetsor- insertionTime létrehozási időt a paraméterben kapja meg.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}");
    }
}

Automatikusan generált function. JSONAutogenerated function.json

A build folyamat létrehoz egy function. JSON fájlt a Build mappában található Function mappában.The build process creates a function.json file in a function folder in the build folder. Amint azt korábban említettük, a fájlt nem közvetlenül kell szerkeszteni.As noted earlier, this file is not meant to be edited directly. Nem módosíthatja a kötési konfigurációt, vagy letilthatja a függvényt a fájl szerkesztésével.You can't change binding configuration or disable the function by editing this file.

Ennek a fájlnak a célja, hogy információt szolgáltasson a méretezési vezérlő számára ahasználati tervre vonatkozó döntések skálázásához.The purpose of this file is to provide information to the scale controller to use for scaling decisions on the consumption plan. Emiatt a fájl csak trigger-információkkal, nem bemeneti vagy kimeneti kötésekkel rendelkezik.For this reason, the file only has trigger info, not input or output bindings.

A generált function. JSON fájl tartalmaz egy configurationSource tulajdonságot, amely azt jelzi, hogy a futtatókörnyezet .net-attribútumokat használ a kötésekhez ahelyett, hogy function. JSON -konfigurációt használjon.The generated function.json file includes a configurationSource property that tells the runtime to use .NET attributes for bindings, rather than function.json configuration. Például: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

A function. JSON -fájl létrehozását a NuGet Package Microsoft..net.SDK függvényekvégzik.The function.json file generation is performed by the NuGet package Microsoft.NET.Sdk.Functions.

Ugyanez a csomag a functions futtatókörnyezet 1. x és 2. x verziójára is használható.The same package is used for both version 1.x and 2.x of the Functions runtime. A cél-keretrendszer az 1. x projekt megkülönböztetése egy 2. x projektből.The target framework is what differentiates a 1.x project from a 2.x project. Az alábbiakban láthatók a . csproj -fájlok azon részei, amelyek különböző cél-keretrendszereket Sdk és azonos csomagot mutatnak be:Here are the relevant parts of .csproj files, showing different target frameworks and the same Sdk package:

Függvények 1. xFunctions 1.x

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

Függvények 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>

A csomagok Sdk függőségei közé az eseményindítók és a kötések tartoznak.Among the Sdk package dependencies are triggers and bindings. Egy 1. x projekt egy 1. x eseményindítóra és kötésre hivatkozik, mivel ezek az eseményindítók és kötések a .NET-keretrendszert célozzák meg, a 2. x eseményindítók és kötések pedig a .NET Core-t célozzák meg.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.

A Sdk csomag a Newtonsoft. JSONfájltól, illetve a WindowsAzure. Storage-ban közvetve is függ.The Sdk package also depends on Newtonsoft.Json, and indirectly on WindowsAzure.Storage. Ezek a függőségek gondoskodnak arról, hogy a projekt azokat a csomagokat használja, amelyek a projekt által megcélzott functions futtatókörnyezet-verzióval működnek.These dependencies make sure that your project uses the versions of those packages that work with the Functions runtime version that the project targets. Például Newtonsoft.Json a .NET-keretrendszer 4.6.1-es Newtonsoft.Json verziójának 11-es verziója, de a .NET-keretrendszer 4.6.1-re irányuló functions futtatókörnyezet csak a 9.0.1 kompatibilis.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. Így a projekt kódjának is a 9.0.1 használatát kell használnia Newtonsoft.Json .So your function code in that project also has to use Newtonsoft.Json 9.0.1.

Microsoft.NET.Sdk.Functions A forráskódja elérhető a GitHub-adattár Azure-functions-vs--Build SDK-ban.The source code for Microsoft.NET.Sdk.Functions is available in the GitHub repo azure-functions-vs-build-sdk.

Futtatókörnyezet verziójaRuntime version

A Visual Studio a Azure functions Core Tools használatával futtatja a functions-projekteket.Visual Studio uses the Azure Functions Core Tools to run Functions projects. A Core Tools a functions futtatókörnyezet parancssori felülete.The Core Tools is a command-line interface for the Functions runtime.

Ha a NPM használatával telepíti az alapvető eszközöket, amelyek nem érintik a Visual Studio által használt alapvető eszközök verzióját.If you install the Core Tools by using npm, that doesn't affect the Core Tools version used by Visual Studio. A functions Runtime 1. x verziójában a Visual Studio a %USERPROFILE%\AppData\Local\Azure.functions.CLI alapeszközök verzióját tárolja, és az ott tárolt legújabb verziót használja.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. A 2. x függvények esetében az alapvető eszközök a Azure functions és a web Jobs Tools bővítmény részét képezik.For Functions 2.x, the Core Tools are included in the Azure Functions and Web Jobs Tools extension. Az 1. x és a 2. x esetében egyaránt megtekintheti, hogy a konzol kimenetében milyen verzió van használatban a functions projekt futtatásakor: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=)

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

Minden kötés saját támogatott típusokkal rendelkezik; például egy blob trigger attribútumot lehet alkalmazni egy karakterlánc-paraméterre, egy poco paraméterre, egy CloudBlockBlob paraméterre vagy számos más támogatott típusra.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. A blob-kötések kötési útmutatója felsorolja az összes támogatott paraméter-típust.The binding reference article for blob bindings lists all supported parameter types. 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.

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 is használhatja, ha az attribútumot a metódus visszatérési értékére alkalmazza.You can use a method return value for an output binding, by applying the attribute to the method return value. 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 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}");
    }
}

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, ahogy az alábbi példában is látható: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}");
    }
} 

Ne használja Console.Write a Azure functions.Avoid using Console.Write in Azure Functions. További információ: a naplók írása C# a functions szolgáltatásban a figyelő Azure functions cikkben.For more information, 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 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);
    }
}

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.

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);
        }
    }
}

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 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);
    }
}

Az Alkalmazásbeállítások a helyi fejlesztésekor és az Azure-ban való futtatáskor is beolvashatók környezeti változókból.App settings can be read from environment variables both when developing locally and when running in Azure. Helyi fejlesztés esetén az Alkalmazásbeállítások a Values Local. Settings. JSON fájlban lévő gyűjteményből származnak.When developing locally, app settings come from the Values collection in the local.settings.json file. Mindkét környezetben, a helyi és az Azure GetEnvironmentVariable("<app setting name>") -ban a megnevezett alkalmazás értékét kérdezi le.In both environments, local and Azure, GetEnvironmentVariable("<app setting name>") retrieves the value of the named app setting. Ha például helyileg fut, a "saját hely neve" értéket adja vissza, ha a Local. Settings. JSON fájl tartalmaz { "Values": { "WEBSITE_SITE_NAME": "My Site Name" } }.For instance, when you're running locally, "My Site Name" would be returned if your local.settings.json file contains { "Values": { "WEBSITE_SITE_NAME": "My Site Name" } }.

A System. Configuration. ConfigurationManager. appSettings tulajdonság egy alternatív API az Alkalmazásbeállítások értékének beolvasásához, de azt javasoljuk, hogy GetEnvironmentVariable használja az itt látható módon.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.

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

A C# -ben és más .net nyelveken a kötelező kötési mintát is használhatja, az attribútumok deklaratív kötéseivel szemben.In C# and other .NET languages, you can use an imperative binding pattern, as opposed to the declarative bindings in attributes. 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 attribútumot a függvény aláírásában a kívánt kényszerített kötésekhez.Do not include an attribute in the function signature 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(...)))
    {
        ...
    }
    

    BindingTypeAttributeaz a .NET-attribútum, amely meghatározza a kötést, és T egy bemeneti vagy kimeneti típus, amelyet az adott kötési típus támogat.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 a IAsyncCollector<t-> t használhatja a kényszerített kötéssel.For example, the Mobile Apps table output binding supports six output types, but you can only use ICollector<T> or IAsyncCollector<T> with imperative binding.

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.

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!");
        };
    }
}

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:

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!!");
        }
    }
}

Eseményindítók és kötésekTriggers and bindings

Az alábbi táblázat a kötések az Azure Functions runtime két fő verziói által támogatott.The following table shows the bindings that are supported in the two major versions of the Azure Functions runtime.

TípusType 1.x1.x 2.x12.x1 EseményindítóTrigger Input (Bemenet)Input KimenetOutput
Blob StorageBlob Storage
Cosmos DBCosmos DB
Event GridEvent Grid
Event HubsEvent Hubs
A HTTP és WebhookokHTTP & Webhooks
A Microsoft Graph
Excel-táblák
Microsoft Graph
Excel tables
A Microsoft Graph
OneDrive-fájlok
Microsoft Graph
OneDrive files
A Microsoft Graph
Outlookos e-mail cím
Microsoft Graph
Outlook email
A Microsoft Graph
események
Microsoft Graph
Events
A Microsoft Graph
hitelesítési jogkivonatok
Microsoft Graph
Auth tokens
Mobile AppsMobile Apps
Értesítési központNotification Hubs
Queue StorageQueue storage
SendGridSendGrid
SzolgáltatásbuszService Bus
SignalRSignalR
Table StorageTable storage
IdőzítőTimer
TwilioTwilio

1 2.x, HTTP- és időzítő kivételével az összes kötések kell regisztrálni.1 In 2.x, all bindings except HTTP and Timer must be registered. Lásd: regisztrálja a kötési bővítményeket.See Register binding extensions.

További lépésekNext steps