Azure Tables kimeneti kötések az Azure Functionshez

Az Azure Tables kimeneti kötésének használatával entitásokat írhat egy táblába az Azure Cosmos DB for Table vagy az Azure Table Storage szolgáltatásban.

A beállítással és a konfigurációval kapcsolatos információkért tekintse meg az áttekintést

Feljegyzés

Ez a kimeneti kötés csak új entitások létrehozását támogatja egy táblában. Ha egy meglévő entitást kell frissítenie a függvénykódból, használja közvetlenül az Azure Tables SDK-t.

Fontos

Ez a cikk lapokat használ a Node.js programozási modell több verziójának támogatásához. A v4-modell általánosan elérhető, és úgy lett kialakítva, hogy rugalmasabb és intuitívabb felhasználói élményt nyújtson JavaScript- és TypeScript-fejlesztők számára. A v4-modell működésével kapcsolatos további információkért tekintse meg az Azure Functions Node.js fejlesztői útmutatóját. A v3 és a v4 közötti különbségekről a migrálási útmutatóban olvashat bővebben.

Példa

A C#-függvények a következő C#-módok egyikével hozhatók létre:

• Izolált feldolgozómodell: Lefordított C# függvény, amely a futtatókörnyezettől elkülönített feldolgozói folyamatban fut. Izolált feldolgozói folyamat szükséges az LTS- és nem LTS-verziókon futó C#-függvények támogatásához .NET és .NET-keretrendszer. Az izolált feldolgozói folyamatfüggvények bővítményei névtereket használnak Microsoft.Azure.Functions.Worker.Extensions.* .
• Folyamaton belüli modell: Lefordított C# függvény, amely ugyanabban a folyamatban fut, mint a Functions-futtatókörnyezet. A modell egy változatában a Functions C#-szkriptekkel futtatható, amely elsősorban a C#-portál szerkesztéséhez támogatott. A folyamaton belüli függvények bővítményei névtereket használnak Microsoft.Azure.WebJobs.Extensions.* .

Fontos

A folyamaton belüli modell támogatása 2026. november 10-én megszűnik. Erősen javasoljuk, hogy az alkalmazásokat az elkülönített feldolgozói modellbe migrálja a teljes támogatás érdekében.

Izolált feldolgozói modell

A következő MyTableData osztály egy adatsort jelöl a táblában:

public class MyTableData : Azure.Data.Tables.ITableEntity
{
    public string Text { get; set; }

    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public DateTimeOffset? Timestamp { get; set; }
    public ETag ETag { get; set; }
}

Az alábbi függvény, amelyet egy Queue Storage-eseményindító indít el, egy új MyDataTable entitást ír egy OutputTable nevű táblába.

[Function("TableFunction")]
[TableOutput("OutputTable", Connection = "AzureWebJobsStorage")]
public static MyTableData Run(
    [QueueTrigger("table-items")] string input,
    [TableInput("MyTable", "<PartitionKey>", "{queueTrigger}")] MyTableData tableInput,
    FunctionContext context)
{
    var logger = context.GetLogger("TableFunction");

    logger.LogInformation($"PK={tableInput.PartitionKey}, RK={tableInput.RowKey}, Text={tableInput.Text}");

    return new MyTableData()
    {
        PartitionKey = "queue",
        RowKey = Guid.NewGuid().ToString(),
        Text = $"Output record with rowkey {input} created at {DateTime.Now}"
    };
}

Folyamaton belüli modell

Az alábbi példa egy C# függvényt mutat be, amely EGY HTTP-eseményindítót használ egyetlen táblasor írásához.

public class TableStorage
{
    public class MyPoco
    {
        public string PartitionKey { get; set; }
        public string RowKey { get; set; }
        public string Text { get; set; }
    }

    [FunctionName("TableOutput")]
    [return: Table("MyTable")]
    public static MyPoco TableOutput([HttpTrigger] dynamic input, ILogger log)
    {
        log.LogInformation($"C# http trigger function processed: {input.Text}");
        return new MyPoco { PartitionKey = "Http", RowKey = Guid.NewGuid().ToString(), Text = input.Text };
    }
}

Az alábbi példa egy Java-függvényt mutat be, amely EGY HTTP-eseményindítót használ egyetlen táblasor írásához.

public class Person {
    private String PartitionKey;
    private String RowKey;
    private String Name;

    public String getPartitionKey() {return this.PartitionKey;}
    public void setPartitionKey(String key) {this.PartitionKey = key; }
    public String getRowKey() {return this.RowKey;}
    public void setRowKey(String key) {this.RowKey = key; }
    public String getName() {return this.Name;}
    public void setName(String name) {this.Name = name; }
}

public class AddPerson {

    @FunctionName("addPerson")
    public HttpResponseMessage get(
            @HttpTrigger(name = "postPerson", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.FUNCTION, route="persons/{partitionKey}/{rowKey}") HttpRequestMessage<Optional<Person>> request,
            @BindingName("partitionKey") String partitionKey,
            @BindingName("rowKey") String rowKey,
            @TableOutput(name="person", partitionKey="{partitionKey}", rowKey = "{rowKey}", tableName="%MyTableName%", connection="MyConnectionString") OutputBinding<Person> person,
            final ExecutionContext context) {

        Person outPerson = new Person();
        outPerson.setPartitionKey(partitionKey);
        outPerson.setRowKey(rowKey);
        outPerson.setName(request.getBody().get().getName());

        person.setValue(outPerson);

        return request.createResponseBuilder(HttpStatus.OK)
                        .header("Content-Type", "application/json")
                        .body(outPerson)
                        .build();
    }
}

Az alábbi példa egy Java-függvényt mutat be, amely HTTP-eseményindítót használ több táblasor írásához.

public class Person {
    private String PartitionKey;
    private String RowKey;
    private String Name;

    public String getPartitionKey() {return this.PartitionKey;}
    public void setPartitionKey(String key) {this.PartitionKey = key; }
    public String getRowKey() {return this.RowKey;}
    public void setRowKey(String key) {this.RowKey = key; }
    public String getName() {return this.Name;}
    public void setName(String name) {this.Name = name; }
}

public class AddPersons {

    @FunctionName("addPersons")
    public HttpResponseMessage get(
            @HttpTrigger(name = "postPersons", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.FUNCTION, route="persons/") HttpRequestMessage<Optional<Person[]>> request,
            @TableOutput(name="person", tableName="%MyTableName%", connection="MyConnectionString") OutputBinding<Person[]> persons,
            final ExecutionContext context) {

        persons.setValue(request.getBody().get());

        return request.createResponseBuilder(HttpStatus.OK)
                        .header("Content-Type", "application/json")
                        .body(request.getBody().get())
                        .build();
    }
}

Az alábbi példa egy táblakimeneti kötést mutat be, amely több táblaentitást ír.

Modell v4

import { app, HttpRequest, HttpResponseInit, InvocationContext, output } from '@azure/functions';

const tableOutput = output.table({
    tableName: 'Person',
    connection: 'MyStorageConnectionAppSetting',
});

interface PersonEntity {
    PartitionKey: string;
    RowKey: string;
    Name: string;
}

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    const rows: PersonEntity[] = [];
    for (let i = 1; i < 10; i++) {
        rows.push({
            PartitionKey: 'Test',
            RowKey: i.toString(),
            Name: `Name ${i}`,
        });
    }
    context.extraOutputs.set(tableOutput, rows);
    return { status: 201 };
}

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [tableOutput],
    handler: httpTrigger1,
});

Modell v3

A TypeScript-minták nincsenek dokumentálva a v3-as modellhez.

Modell v4

const { app, output } = require('@azure/functions');

const tableOutput = output.table({
    tableName: 'Person',
    connection: 'MyStorageConnectionAppSetting',
});

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [tableOutput],
    handler: async (request, context) => {
        const rows = [];
        for (let i = 1; i < 10; i++) {
            rows.push({
                PartitionKey: 'Test',
                RowKey: i.toString(),
                Name: `Name ${i}`,
            });
        }
        context.extraOutputs.set(tableOutput, rows);
        return { status: 201 };
    },
});

Modell v3

Íme a function.json fájl:

{
  "bindings": [
    {
      "name": "input",
      "type": "manualTrigger",
      "direction": "in"
    },
    {
      "tableName": "Person",
      "connection": "MyStorageConnectionAppSetting",
      "name": "tableBinding",
      "type": "table",
      "direction": "out"
    }
  ],
  "disabled": false
}

A konfigurációs szakasz ezeket a tulajdonságokat ismerteti.

A JavaScript-kód a következő:

module.exports = async function (context) {

    context.bindings.tableBinding = [];

    for (var i = 1; i < 10; i++) {
        context.bindings.tableBinding.push({
            PartitionKey: "Test",
            RowKey: i.toString(),
            Name: "Name " + i
        });
    }
};

Az alábbi példa bemutatja, hogyan írhat több entitást egy táblába egy függvényből.

Kötéskonfiguráció a function.json:

{
  "bindings": [
    {
      "name": "InputData",
      "type": "manualTrigger",
      "direction": "in"
    },
    {
      "tableName": "Person",
      "connection": "MyStorageConnectionAppSetting",
      "name": "TableBinding",
      "type": "table",
      "direction": "out"
    }
  ],
  "disabled": false
}

PowerShell-kód a run.ps1-ben:

param($InputData, $TriggerMetadata)

foreach ($i in 1..10) {
    Push-OutputBinding -Name TableBinding -Value @{
        PartitionKey = 'Test'
        RowKey = "$i"
        Name = "Name $i"
    }
}

Az alábbi példa bemutatja, hogyan használható a Table Storage kimeneti kötése. Konfigurálja a kötést table a function.json úgy, hogy az értékeket a következőhöz connectionnametableNamepartitionKeyrendeli:

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "message",
      "type": "table",
      "tableName": "messages",
      "partitionKey": "message",
      "connection": "AzureWebJobsStorage",
      "direction": "out"
    },
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
  ]
}

Az alábbi függvény létrehoz egy egyedi UUI-t az rowKey értékhez, és megőrzi az üzenetet a Table Storage-ba.

import logging
import uuid
import json

import azure.functions as func

def main(req: func.HttpRequest, message: func.Out[str]) -> func.HttpResponse:

    rowKey = str(uuid.uuid4())

    data = {
        "Name": "Output binding message",
        "PartitionKey": "message",
        "RowKey": rowKey
    }

    message.set(json.dumps(data))

    return func.HttpResponse(f"Message created with the rowKey: {rowKey}")

---

Attribútumok

A folyamaton belüli és az izolált feldolgozói folyamat C# kódtárai attribútumokkal határozzák meg a függvényt. A C#-szkript ehelyett egy function.json konfigurációs fájlt használ a C#-szkriptelési útmutatóban leírtak szerint.

Izolált feldolgozói modell

A C#-osztálykódtárakban a TableInputAttribute következő tulajdonságok támogatottak:

Attribútumtulajdonság	Leírás
TableName	Annak a táblának a neve, amelyhez írni szeretne.
PartitionKey	Az írni kívánt táblaentitás partíciókulcsa.
Sorkulcs	Az írni kívánt táblaentitás sorkulcsa.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Kapcsolatok.

Folyamaton belüli modell

A C#-osztálykódtárakban a TableAttribute következő tulajdonságok támogatottak:

Attribútumtulajdonság	Leírás
TableName	Annak a táblának a neve, amelyhez írni szeretne.
PartitionKey	Az írni kívánt táblaentitás partíciókulcsa.
Sorkulcs	Az írni kívánt táblaentitás sorkulcsa.
Kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Kapcsolatok.

Az attribútum konstruktora a tábla nevét veszi fel. Használja az attribútumot egy out paraméteren vagy a függvény visszatérési értékén az alábbi példában látható módon:

[FunctionName("TableOutput")]
[return: Table("MyTable")]
public static MyPoco TableOutput(
    [HttpTrigger] dynamic input, 
    ILogger log)
{
    ...
}

A tulajdonságot úgy állíthatja be Connection , hogy kapcsolatot adjon meg a táblaszolgáltatással, ahogy az a következő példában látható:

[FunctionName("TableOutput")]
[return: Table("MyTable", Connection = "StorageConnectionAppSetting")]
public static MyPoco TableOutput(
    [HttpTrigger] dynamic input, 
    ILogger log)
{
    ...
}

Bár az attribútum egy tulajdonságot Connection használ, a StorageAccountAttribute használatával is megadhat egy tárfiók-kapcsolatot. Ezt akkor teheti meg, ha más tárfiókot kell használnia, mint a tár más funkcióit. A konstruktor egy tárolási kapcsolati sztring tartalmazó alkalmazásbeállítás nevét veszi fel. Az attribútum a paraméter, a metódus vagy az osztály szintjén alkalmazható. Az alábbi példa az osztályszintet és a metódusszintet mutatja be:

[StorageAccount("ClassLevelStorageAppSetting")]
public static class AzureFunctions
{
    [FunctionName("StorageTrigger")]
    [StorageAccount("FunctionLevelStorageAppSetting")]
    public static void Run( //...
{
    ...
}

A használni kívánt tárfiók meghatározása a következő sorrendben történik:

• Az eseményindító vagy kötés attribútum tulajdonsága Connection .
• A StorageAccount trigger vagy kötés attribútummal azonos paraméterre alkalmazott attribútum.
• A StorageAccount függvényre alkalmazott attribútum.
• Az StorageAccount osztályra alkalmazott attribútum.
• A függvényalkalmazás alapértelmezett tárfiókja, amely az AzureWebJobsStorage alkalmazásbeállításban van definiálva.

Jegyzetek

A Java-függvények futtatókörnyezeti kódtárában a TableOutput annotation on parameters használatával írjon értékeket a táblákba. Az attribútum a következő elemeket támogatja:

Elem	Leírás
név	A táblát vagy entitást képviselő függvénykódban használt változónév.
Adattípus	Meghatározza, hogy a Functions futtatókörnyezet hogyan kezelje a paraméter értékét. További információ: dataType.
tableName	Annak a táblának a neve, amelyhez írni szeretne.
partitionKey	Az írni kívánt táblaentitás partíciókulcsa.
rowKey	Az írni kívánt táblaentitás sorkulcsa.
kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Kapcsolatok.

Konfiguráció

Modell v4

Az alábbi táblázat a metódusnak output.table() átadott objektumon options beállítható tulajdonságokat ismerteti.

Tulajdonság	Leírás
tableName	Annak a táblának a neve, amelyhez írni szeretne.
partitionKey	Az írni kívánt táblaentitás partíciókulcsa.
rowKey	Az írni kívánt táblaentitás sorkulcsa.
kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Kapcsolatok.

Modell v3

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

Tulajdonság	Leírás
type	A beállításnak a tablekövetkezőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
direction	A beállításnak a outkövetkezőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
név	A táblát vagy entitást képviselő függvénykódban használt változónév. $return A függvény visszatérési értékére való hivatkozásra van állítva.
tableName	Annak a táblának a neve, amelyhez írni szeretne.
partitionKey	Az írni kívánt táblaentitás partíciókulcsa.
rowKey	Az írni kívánt táblaentitás sorkulcsa.
kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Kapcsolatok.

Konfiguráció

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

function.json tulajdonság	Leírás
type	A beállításnak a tablekövetkezőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
direction	A beállításnak a outkövetkezőnek kell lennie: . Ez a tulajdonság automatikusan be van állítva, amikor létrehozza a kötést az Azure Portalon.
név	A táblát vagy entitást képviselő függvénykódban használt változónév. $return A függvény visszatérési értékére való hivatkozásra van állítva.
tableName	Annak a táblának a neve, amelyhez írni szeretne.
partitionKey	Az írni kívánt táblaentitás partíciókulcsa.
rowKey	Az írni kívánt táblaentitás sorkulcsa.
kapcsolat	Egy alkalmazásbeállítás vagy beállításgyűjtemény neve, amely meghatározza, hogyan csatlakozhat a táblaszolgáltatáshoz. Lásd: Kapcsolatok.

Helyi fejlesztéskor adja hozzá az alkalmazásbeállításokat a gyűjtemény local.settings.json fájljáhozValues.

Kapcsolatok

A connection tulajdonság a környezeti konfigurációra mutató hivatkozás, amely meghatározza, hogy az alkalmazásnak hogyan kell csatlakoznia a táblaszolgáltatáshoz. A következőt határozhatja meg:

• Egy kapcsolati sztring tartalmazó alkalmazásbeállítás neve
• Megosztott előtag neve több alkalmazásbeállításhoz, valamint identitásalapú kapcsolat definiálása

Ha a konfigurált érték egy adott beállítás pontos egyezése, a többi beállítás előtagja pedig egyezik, akkor a rendszer a pontos egyezést használja.

Kapcsolati sztring

Ha kapcsolati sztring szeretne beszerezni a táblákhoz az Azure Table Storage-ban, kövesse a tárfiók hozzáférési kulcsainak kezelése című témakörben ismertetett lépéseket. Ha kapcsolati sztring szeretne beszerezni a táblákhoz az Azure Cosmos DB for Table szolgáltatásban, kövesse az Azure Cosmos DB for Table GYIK-ben ismertetett lépéseket.

Ezt a kapcsolati sztring a kötéskonfiguráció tulajdonsága által connection megadott értéknek megfelelő névvel rendelkező alkalmazásbeállításban kell tárolni.

Ha az alkalmazásbeállítás neve az "AzureWebJobs" névvel kezdődik, itt csak a név fennmaradó részét adhatja meg. Ha például a "MyStorage" értékre van állítva connection , a Functions-futtatókörnyezet egy "AzureWebJobsMyStorage" nevű alkalmazásbeállítást keres. Ha üresen hagyjaconnection, a Functions-futtatókörnyezet az alapértelmezett Storage-kapcsolati sztring használja a névvel ellátott AzureWebJobsStoragealkalmazásbeállításban.

Identitásalapú kapcsolatok

Ha a Tables API-bővítményt használja, ahelyett, hogy titkos kapcsolati sztring használ, az alkalmazás Microsoft Entra-identitást használhat. Ez csak az Azure Storage-táblák elérésekor érvényes. Identitás használatához olyan beállításokat kell megadnia egy közös előtag alatt, amely leképezi a tulajdonságot az connection eseményindító és a kötés konfigurációjában.

Ha az "AzureWebJobsStorage" beállítást választjaconnection, olvassa el a Csatlakozás a gazdagép tárolójához identitással című témakört. Az összes többi kapcsolat esetében a bővítményhez a következő tulajdonságok szükségesek:

Tulajdonság	Környezeti változó sablonja	Leírás	Példaérték
Table Service URI	<CONNECTION_NAME_PREFIX>__tableServiceUri1	Annak az Azure Storage table service-nek az adatsík URI-ja, amelyhez csatlakozik, a HTTPS-séma használatával.	<https:// storage_account_name.table.core.windows.net>

^{Az 1} <CONNECTION_NAME_PREFIX>__serviceUri aliasként használható. Ha mindkét űrlap meg van adva, a rendszer az tableServiceUri űrlapot használja. Az serviceUri űrlap nem használható, ha az általános kapcsolatkonfigurációt blobokon, üzenetsorokon és/vagy táblákon kell használni.

Más tulajdonságok is beállíthatók a kapcsolat testreszabásához. Tekintse meg az identitásalapú kapcsolatok gyakori tulajdonságait.

Az serviceUri űrlap nem használható, ha az általános kapcsolatkonfigurációt blobokon, üzenetsorokon és/vagy táblákon kell használni az Azure Storage-ban. Az URI csak a táblaszolgáltatást tudja kijelölni. Alternatív megoldásként megadhat egy URI-t kifejezetten minden szolgáltatáshoz ugyanazon előtag alatt, lehetővé téve egyetlen kapcsolat használatát.

Az Azure Functions szolgáltatásban üzemeltetett identitásalapú kapcsolatok felügyelt identitást használnak. A rendszer alapértelmezés szerint a rendszer által hozzárendelt identitást használja, bár a felhasználó által hozzárendelt identitás megadható a credential tulajdonságokkal együtt clientID . Vegye figyelembe, hogy a felhasználó által hozzárendelt identitás erőforrás-azonosítóval való konfigurálása nem támogatott. Ha más környezetekben, például helyi fejlesztésben fut, a rendszer ehelyett a fejlesztői identitást használja, bár ez testre szabható. Lásd: Helyi fejlesztés identitásalapú kapcsolatokkal.

Engedély megadása az identitáshoz

Bármilyen identitást is használ, rendelkeznie kell a kívánt műveletek végrehajtásához szükséges engedélyekkel. A legtöbb Azure-szolgáltatás esetében ez azt jelenti, hogy egy szerepkört kell hozzárendelnie az Azure RBAC-ben beépített vagy egyéni szerepkörökkel, amelyek biztosítják ezeket az engedélyeket.

Fontos

A célszolgáltatás bizonyos engedélyeket közzétehet, amelyek nem minden környezethez szükségesek. Ahol lehetséges, tartsa be a minimális jogosultság elvét, és csak az identitáshoz szükséges jogosultságokat adja meg. Ha például az alkalmazásnak csak adatforrásból kell olvasnia, használjon olyan szerepkört, amely csak olvasási engedéllyel rendelkezik. Nem lenne helyénvaló olyan szerepkört hozzárendelni, amely lehetővé teszi az írást is a szolgáltatáshoz, mivel ez túlzott engedély lenne egy olvasási művelethez. Hasonlóképpen meg szeretné győződni arról, hogy a szerepkör-hozzárendelés csak az elolvasandó erőforrásokra terjed ki.

Létre kell hoznia egy szerepkör-hozzárendelést, amely futtatókörnyezetben hozzáférést biztosít az Azure Storage-táblaszolgáltatáshoz. A tulajdonoshoz hasonló felügyeleti szerepkörök nem elegendőek. Az alábbi táblázat a beépített szerepköröket mutatja be, amelyeket az Azure Tables bővítmény az Azure Storage-ra való normál működés során történő használatakor ajánlott. Előfordulhat, hogy az alkalmazás további engedélyeket igényel az Ön által írt kód alapján.

Kötés típusa	Példa beépített szerepkörökre (Azure Storage1)
Bemeneti kötés	Tárolótábla adatolvasója
Kimeneti kötés	Storage Table Data Közreműködő

¹ Ha az alkalmazás ehelyett táblákhoz csatlakozik az Azure Cosmos DB for Table szolgáltatásban, az identitás használata nem támogatott, és a kapcsolatnak kapcsolati sztring kell használnia.

Használat

A kötés használata a bővítménycsomag verziójától és a függvényalkalmazásban használt C# modalitástól függ, amely az alábbiak egyike lehet:

Izolált feldolgozói modell

A C# függvényt lefordított izolált feldolgozói folyamatosztály-kódtár a futtatókörnyezettől elkülönített folyamatban fut.

Folyamaton belüli modell

A folyamatközi osztálykódtár egy lefordított C# függvény, amely ugyanabban a folyamatban fut, mint a Functions-futtatókörnyezet.

Válasszon egy verziót a mód és a verzió használati adatainak megtekintéséhez.

Azure Tables-bővítmény

A paraméterek és a visszatérési típusok esetében out a következő típusok támogatottak:

• Egyszerű régi CLR-objektum (POCO), amely tartalmazza a PartitionKey tulajdonságokat.RowKey Ezeket a tulajdonságokat a implementálással ITableEntitykísérheti.
• ICollector<T> vagy IAsyncCollector<T> ahol T a PartitionKey tulajdonságokat is RowKey tartalmazza. Ezeket a tulajdonságokat a implementálással ITableEntitykísérheti.

Az Azure SDK-ból is kapcsolódhat.TableClient Ezután ezzel az objektummal írhat a táblába.

Kombinált Azure Storage-bővítmény

A paraméterek és a visszatérési típusok esetében out a következő típusok támogatottak:

• Egyszerű régi CLR-objektum (POCO), amely tartalmazza a PartitionKey tulajdonságokat.RowKey Ezeket a tulajdonságokat implementálhatja ITableEntity vagy örökölheti TableEntity.
• ICollector<T> vagy IAsyncCollector<T> ahol T a PartitionKey tulajdonságokat is RowKey tartalmazza. Ezeket a tulajdonságokat implementálhatja ITableEntity vagy örökölheti TableEntity.

A Storage SDK-hoz metódusparaméterként is kapcsolódhat.CloudTable Ezután ezzel az objektummal írhat a táblába.

Functions 1.x

A paraméterek és a visszatérési típusok esetében out a következő típusok támogatottak:

• Egyszerű régi CLR-objektum (POCO), amely tartalmazza a PartitionKey tulajdonságokat.RowKey Ezeket a tulajdonságokat implementálhatja ITableEntity vagy örökölheti TableEntity.
• ICollector<T> vagy IAsyncCollector<T> ahol T a PartitionKey tulajdonságokat is RowKey tartalmazza. Ezeket a tulajdonságokat implementálhatja ITableEntity vagy örökölheti TableEntity.

A Storage SDK-hoz metódusparaméterként is kapcsolódhat.CloudTable Ezután ezzel az objektummal írhat a táblába.

Azure Tables-bővítmény

Ha azt szeretné, hogy a függvény egyetlen entitásba írjon, az Azure Tables kimeneti kötése a következő típusokhoz kapcsolódhat:

Típus	Leírás
Az [ITableEntity] implementálását megvalósító JSON szerializálható típus	A Functions egy egyszerű régi CLR-objektumtípust (POCO) kísérel meg entitásként szerializálni. A típusnak implementálnia kell az [ITableEntity] elemet, vagy sztringtulajdonságokkal RowKey és sztringtulajdonságokkal PartitionKey kell rendelkeznie.

Ha azt szeretné, hogy a függvény több entitásba írjon, az Azure Tables kimeneti kötése a következő típusokhoz kapcsolódhat:

Típus	Leírás
T[] ahol T az egyetlen entitástípusok egyike	Több entitást tartalmazó tömb. Minden bejegyzés egy entitást jelöl.

Egyéb kimeneti forgatókönyvek esetén közvetlenül hozzon létre és használjon típusokat az Azure.Data.Tables szolgáltatásból.

Kombinált Azure Storage-bővítmény

Egy egyszerű régi CLR-objektumot (POCO) ad vissza, amely a táblaentitáshoz leképezhető tulajdonságokkal rendelkezik.

Functions 1.x

A Functions 1.x-es verziója nem támogatja az izolált feldolgozói folyamatot.

A TableStorageOutput széljegyzet használatával két lehetőség közül választhat, ha táblatároló sort ad ki egy függvényből:

Beállítások	Leírás
Visszaadott érték	A széljegyzet magára a függvényre való alkalmazásával a függvény visszatérési értéke táblatároló sorként marad meg.
Felszólító mód	A táblázatsor explicit beállításához alkalmazza a széljegyzetet a típus OutputBinding<T>egy adott paraméterére, ahol T a tulajdonságok és RowKey a PartitionKey tulajdonságok is szerepelnek. Ezeket a tulajdonságokat implementálhatja ITableEntity vagy örökölheti TableEntity.

Modell v4

Állítsa be a kimeneti sor adatait az érték visszaadásával vagy a használatával context.extraOutputs.set().

Modell v3

Állítsa be a kimeneti sor adatait a function.json <name>tulajdonságában name megadott érték alapjáncontext.bindings.<name>.

Táblázatadatokba való íráshoz használja a Push-OutputBinding parancsmagot, állítsa be a paramétert és -Value a -Name TableBinding paramétert, amely megegyezik a soradatokkal. További részletekért tekintse meg a PowerShell-példát .

A Table Storage sorüzenetének függvényből való kimenetére két lehetőség van:

Beállítások	Leírás
Visszaadott érték	Állítsa a tulajdonságot a name function.json értékére$return. Ezzel a konfigurációval a függvény visszatérési értéke táblatároló sorként marad meg.
Felszólító mód	Adjon meg egy értéket a Ki típusúként deklarált paraméter beállított metódusának. Az átadott set érték táblasorként marad meg.

A konkrét használati adatokért lásd a példát.

Kivételek és visszatérési kódok

Kötés	Referencia
Tábla	Táblahibakódok
Blob, tábla, üzenetsor	Tárolási hibakódok
Blob, tábla, üzenetsor	Hibaelhárítás

Következő lépések

További információ az Azure Functions eseményindítóiról és kötéseiről