Associazioni di input di tabelle di Azure per Funzioni di Azure

Una libreria di classi di processo di lavoro isolata compilata C# viene eseguita in un processo isolato dal runtime.

Una libreria di classi in-process è una funzione C# compilata eseguita nello stesso processo del runtime di Funzioni.

L'esempio seguente mostra una funzione C# che legge una singola riga della tabella. Per ogni messaggio inviato alla coda, la funzione verrà attivata.

Il valore {queueTrigger} della chiave di riga associa la chiave di riga ai metadati del messaggio, ovvero la stringa del messaggio.

public class TableStorage
{
    public class MyPoco : 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; }
    }


    [FunctionName("TableInput")]
    public static void TableInput(
        [QueueTrigger("table-items")] string input, 
        [Table("MyTable", "MyPartition", "{queueTrigger}")] MyPoco poco, 
        ILogger log)
    {
        log.LogInformation($"PK={poco.PartitionKey}, RK={poco.RowKey}, Text={poco.Text}");
    }
}

Usare un TableClient parametro del metodo per leggere la tabella usando Azure SDK. Di seguito è riportato un esempio di funzione che esegue una query su una tabella di log Funzioni di Azure:

using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;
using Azure.Data.Tables;
using System;
using System.Threading.Tasks;
using Azure;
namespace FunctionAppCloudTable2
{
    public class LogEntity : ITableEntity
    {
        public string OriginalName { get; set; }

        public string PartitionKey { get; set; }
        public string RowKey { get; set; }
        public DateTimeOffset? Timestamp { get; set; }
        public ETag ETag { get; set; }
    }
    public static class CloudTableDemo
    {
        [FunctionName("CloudTableDemo")]
        public static async Task Run(
            [TimerTrigger("0 */1 * * * *")] TimerInfo myTimer,
            [Table("AzureWebJobsHostLogscommon")] TableClient tableClient,
            ILogger log)
        {
            log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
            AsyncPageable<LogEntity> queryResults = tableClient.QueryAsync<LogEntity>(filter: $"PartitionKey eq 'FD2' and RowKey gt 't'");
            await foreach (LogEntity entity in queryResults)
            {
                log.LogInformation($"{entity.PartitionKey}\t{entity.RowKey}\t{entity.Timestamp}\t{entity.OriginalName}");
            }
        }
    }
}

Per altre informazioni su come usare TableClient, vedere le informazioni di riferimento sull'API Azure.Data.Tables.

L'esempio seguente mostra una funzione C# che legge una singola riga della tabella. Per ogni messaggio inviato alla coda, la funzione verrà attivata.

Il valore {queueTrigger} della chiave di riga associa la chiave di riga ai metadati del messaggio, ovvero la stringa del messaggio.

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

    [FunctionName("TableInput")]
    public static void TableInput(
        [QueueTrigger("table-items")] string input, 
        [Table("MyTable", "MyPartition", "{queueTrigger}")] MyPoco poco, 
        ILogger log)
    {
        log.LogInformation($"PK={poco.PartitionKey}, RK={poco.RowKey}, Text={poco.Text}");
    }
}

Usare un CloudTable parametro del metodo per leggere la tabella usando Archiviazione di Azure SDK. Di seguito è riportato un esempio di funzione che esegue una query su una tabella di log Funzioni di Azure:

using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;
using Microsoft.Azure.Cosmos.Table;
using System;
using System.Threading.Tasks;

namespace FunctionAppCloudTable2
{
    public class LogEntity : TableEntity
    {
        public string OriginalName { get; set; }
    }
    public static class CloudTableDemo
    {
        [FunctionName("CloudTableDemo")]
        public static async Task Run(
            [TimerTrigger("0 */1 * * * *")] TimerInfo myTimer, 
            [Table("AzureWebJobsHostLogscommon")] CloudTable cloudTable,
            ILogger log)
        {
            log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");

            TableQuery<LogEntity> rangeQuery = new TableQuery<LogEntity>().Where(
                TableQuery.CombineFilters(
                    TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, 
                        "FD2"),
                    TableOperators.And,
                    TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.GreaterThan, 
                        "t")));

            // Execute the query and loop through the results
            foreach (LogEntity entity in 
                await cloudTable.ExecuteQuerySegmentedAsync(rangeQuery, null))
            {
                log.LogInformation(
                    $"{entity.PartitionKey}\t{entity.RowKey}\t{entity.Timestamp}\t{entity.OriginalName}");
            }
        }
    }
}

Per altre informazioni su come usare CloudTable, vedere Introduzione all'archiviazione tabelle di Azure.

Se si prova a eseguire l'associazione a CloudTable e si riceve un messaggio di errore, assicurarsi di fare riferimento alla versione corretta di Storage SDK.

L'esempio seguente mostra una funzione C# che legge una singola riga della tabella. Per ogni messaggio inviato alla coda, la funzione verrà attivata.

Il valore {queueTrigger} della chiave di riga associa la chiave di riga ai metadati del messaggio, ovvero la stringa del messaggio.

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

    [FunctionName("TableInput")]
    public static void TableInput(
        [QueueTrigger("table-items")] string input, 
        [Table("MyTable", "MyPartition", "{queueTrigger}")] MyPoco poco, 
        ILogger log)
    {
        log.LogInformation($"PK={poco.PartitionKey}, RK={poco.RowKey}, Text={poco.Text}");
    }
}

L'esempio seguente illustra una funzione C# che legge più righe di tabella in cui la MyPoco classe deriva da TableEntity.

public class TableStorage
{
    public class MyPoco : TableEntity
    {
        public string Text { get; set; }
    }

    [FunctionName("TableInput")]
    public static void TableInput(
        [QueueTrigger("table-items")] string input, 
        [Table("MyTable", "MyPartition")] IQueryable<MyPoco> pocos, 
        ILogger log)
    {
        foreach (MyPoco poco in pocos)
        {
            log.LogInformation($"PK={poco.PartitionKey}, RK={poco.RowKey}, Text={poco.Text}");
        }
    }
}

La classe seguente MyTableData rappresenta una riga di dati nella tabella:

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

La funzione seguente, avviata da un trigger di archiviazione code, legge una chiave di riga dalla coda, che viene usata per ottenere la riga dalla tabella di input. L'espressione {queueTrigger} associa la chiave di riga ai metadati del messaggio, ovvero la stringa del messaggio.

[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}"
    };
}

La funzione attivata dalla coda seguente restituisce le prime 5 entità come IEnumerable<T>, con il valore della chiave di partizione impostato come messaggio della coda.

[Function("TestFunction")]
public static void Run([QueueTrigger("myqueue", Connection = "AzureWebJobsStorage")] string partition,
    [TableInput("inTable", "{queueTrigger}", Take = 5, Filter = "Text eq 'test'", 
    Connection = "AzureWebJobsStorage")] IEnumerable<MyTableData> tableInputs,
    FunctionContext context)
{
    var logger = context.GetLogger("TestFunction");
    logger.LogInformation(partition);
    foreach (MyTableData tableInput in tableInputs)
    {
        logger.LogInformation($"PK={tableInput.PartitionKey}, RK={tableInput.RowKey}, Text={tableInput.Text}");
    }
}

Le Filter proprietà e Take vengono usate per limitare il numero di entità restituite.

La classe seguente MyTableData rappresenta una riga di dati nella tabella:

{
    var tableEntities = table.QueryAsync<TableEntity>(filter: $"RowKey eq '{rowKey}'");

    await foreach (TableEntity entity in tableEntities)
    {
        _logger.LogInformation("PK={pk}, RK={rk}, Text={t}", entity.PartitionKey, entity.RowKey, entity["Text"]);
    }

La funzione seguente, avviata da un trigger di archiviazione code, legge una chiave di riga dalla coda, che viene usata per ottenere la riga dalla tabella di input. L'espressione {queueTrigger} associa la chiave di riga ai metadati del messaggio, ovvero la stringa del messaggio.

namespace SampleApp
{
    public class TableFunction
    {
        private readonly ILogger<TableFunction> _logger;

        public TableFunction(ILogger<TableFunction> logger)
        {
            _logger = logger;
        }

        /// <summary>
        /// This function demonstrates binding to a single <see cref="TableClient"/>
        /// and using the client for output.
        /// </summary>
        [Function(nameof(TableFunction))]
        public async Task Run(
            [QueueTrigger("table-items")] string rowKey,

La funzione attivata dalla coda seguente restituisce le prime 5 entità come IEnumerable<T>, con il valore della chiave di partizione impostato come messaggio della coda.

[Function("TestFunction")]
public static void Run([QueueTrigger("myqueue", Connection = "AzureWebJobsStorage")] string partition,
    [TableInput("inTable", "{queueTrigger}", Take = 5, Filter = "Text eq 'test'", 
    Connection = "AzureWebJobsStorage")] IEnumerable<MyTableData> tableInputs,
    FunctionContext context)
{
    var logger = context.GetLogger("TestFunction");
    logger.LogInformation(partition);
    foreach (MyTableData tableInput in tableInputs)
    {
        logger.LogInformation($"PK={tableInput.PartitionKey}, RK={tableInput.RowKey}, Text={tableInput.Text}");
    }
}

Le Filter proprietà e Take vengono usate per limitare il numero di entità restituite.

Le funzioni versione 1.x non supportano il processo di lavoro isolato.

import { app, input, InvocationContext } from '@azure/functions';

const tableInput = input.table({
    tableName: 'Person',
    partitionKey: 'Test',
    rowKey: '{queueTrigger}',
    connection: 'MyStorageConnectionAppSetting',
});

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

export async function storageQueueTrigger1(queueItem: unknown, context: InvocationContext): Promise<void> {
    context.log('Node.js queue trigger function processed work item', queueItem);
    const person = <PersonEntity>context.extraInputs.get(tableInput);
    context.log('Person entity name: ' + person.Name);
}

app.storageQueue('storageQueueTrigger1', {
    queueName: 'myqueue-items',
    connection: 'MyStorageConnectionAppSetting',
    extraInputs: [tableInput],
    handler: storageQueueTrigger1,
});

Gli esempi typeScript non sono documentati per il modello v3.

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

const tableInput = input.table({
    tableName: 'Person',
    partitionKey: 'Test',
    rowKey: '{queueTrigger}',
    connection: 'MyStorageConnectionAppSetting',
});

app.storageQueue('storageQueueTrigger1', {
    queueName: 'myqueue-items',
    connection: 'MyStorageConnectionAppSetting',
    extraInputs: [tableInput],
    handler: (queueItem, context) => {
        context.log('Node.js queue trigger function processed work item', queueItem);
        const person = context.extraInputs.get(tableInput);
        context.log('Person entity name: ' + person.Name);
    },
});

{
  "bindings": [
    {
      "queueName": "myqueue-items",
      "connection": "MyStorageConnectionAppSetting",
      "name": "myQueueItem",
      "type": "queueTrigger",
      "direction": "in"
    },
    {
      "name": "personEntity",
      "type": "table",
      "tableName": "Person",
      "partitionKey": "Test",
      "rowKey": "{queueTrigger}",
      "connection": "MyStorageConnectionAppSetting",
      "direction": "in"
    }
  ],
  "disabled": false
}

Queste proprietà sono descritte nella sezione configuration.

Ecco il codice JavaScript:

module.exports = async function (context, myQueueItem) {
    context.log('Node.js queue trigger function processed work item', myQueueItem);
    context.log('Person entity name: ' + context.bindings.personEntity.Name);
};

import json
import azure.functions as func

app = func.FunctionApp()

@app.route(route="messages/{id}")
@app.table_input(arg_name="messageJSON",
                 connection="AzureWebJobsStorage",
                 table_name="messages",
                 row_key='{id}',
                 partition_key="message")
def table_in_binding(req: func.HttpRequest, messageJSON):
    message = json.loads(messageJSON)
    return func.HttpResponse(f"Table row: {messageJSON}")

Con questa semplice associazione, non è possibile gestire a livello di codice un caso in cui non viene trovata alcuna riga con ID chiave di riga. Per una selezione più dettagliata dei dati, usare l'SDK di archiviazione.

Configurazione dell'associazione nel file function.json :

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

Codice Python nel file __init__.py :

import json

import azure.functions as func

def main(req: func.HttpRequest, messageJSON) -> func.HttpResponse:

    message = json.loads(messageJSON)
    return func.HttpResponse(f"Table row: {messageJSON}")

Con questa semplice associazione, non è possibile gestire a livello di codice un caso in cui non viene trovata alcuna riga con ID chiave di riga. Per una selezione più dettagliata dei dati, usare l'SDK di archiviazione.

Nelle librerie diTableInputAttribute classi C# supporta le proprietà seguenti:

Nelle librerie diTableAttribute classi C# supporta le proprietà seguenti:

Il costruttore dell'attributo accetta il nome della tabella, la chiave di partizione e la chiave di riga, come illustrato nell'esempio seguente:

[FunctionName("TableInput")]
public static void Run(
    [QueueTrigger("table-items")] string input, 
    [Table("MyTable", "Http", "{queueTrigger}")] MyPoco poco, 
    ILogger log)
{
    ...
}

È possibile impostare la Connection proprietà per specificare la connessione al servizio tabelle, come illustrato nell'esempio seguente:

[FunctionName("TableInput")]
public static void Run(
    [QueueTrigger("table-items")] string input, 
    [Table("MyTable", "Http", "{queueTrigger}", Connection = "StorageConnectionAppSetting")] MyPoco poco, 
    ILogger log)
{
    ...
}

Mentre l'attributo accetta una Connection proprietà, è anche possibile usare StorageAccountAttribute per specificare una connessione all'account di archiviazione. Questa operazione può essere eseguita quando è necessario usare un account di archiviazione diverso da altre funzioni della libreria. Il costruttore accetta il nome di un'impostazione dell'app che contiene una stringa di connessione di archiviazione. L'attributo può essere applicato a livello di parametro, metodo o classe. L'esempio seguente illustra il livello classe e il livello metodo:

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

L'account di archiviazione da usare è determinato nell'ordine seguente:

• Proprietà dell'attributo trigger o binding Connection .
• Attributo StorageAccount applicato allo stesso parametro dell'attributo trigger o binding.
• L'attributo StorageAccount applicato alla funzione.
• L'attributo StorageAccount applicato alla classe.
• L'account di archiviazione predefinito per l'app per le funzioni, definito nell'impostazione dell'applicazione AzureWebJobsStorage .

Nella tabella seguente vengono illustrate le proprietà che è possibile impostare sull'oggetto options passato al input.table() metodo .

Nella tabella seguente sono illustrate le proprietà di configurazione dell'associazione impostate nel file function.json.

Una funzione C# compilata di libreria di classi di processo di lavoro viene eseguita in un processo isolato dal runtime.

Una libreria di classi in-process è una funzione C# compilata che viene eseguita nello stesso processo del runtime di Funzioni.

Per restituire un'entità specifica per chiave, usare un parametro di associazione che deriva da TableEntity.

Per eseguire query che restituiscono più entità, eseguire l'associazione a un oggetto [TableClient]. È quindi possibile usare questo oggetto per creare ed eseguire query sulla tabella associata. Si noti che [TableClient] e le API correlate appartengono allo spazio dei nomi Azure.Data.Tables .

Per restituire un'entità specifica per chiave, usare un parametro di associazione che deriva da TableEntity.

Per eseguire query che restituiscono più entità, eseguire l'associazione a un oggetto CloudTable . È quindi possibile usare questo oggetto per creare ed eseguire query sulla tabella associata. Si noti che CloudTable e le API correlate appartengono allo spazio dei nomi Microsoft.Azure.Cosmos.Table .

Per restituire un'entità specifica per chiave, usare un parametro di associazione che deriva da TableEntity. Gli oggetti , TableNamee PartitionKey specifici RowKeyvengono usati per provare a ottenere un'entità specifica dalla tabella.

Per eseguire query che restituiscono più entità, eseguire l'associazione a un IQueryable<T> di un tipo che eredita da TableEntity.

Quando si usa una singola entità di tabella, l'associazione di input tabelle di Azure può essere associata ai tipi seguenti:

Quando si usano più entità da una query, l'associazione di input tabelle di Azure può essere associata ai tipi seguenti:

¹ Per usare questi tipi, è necessario fare riferimento a Microsoft.Azure.Functions.Worker.Extensions.Tables 1.2.0 o versioni successive e alle dipendenze comuni per le associazioni di tipi SDK.

Per restituire un'entità specifica in base alla chiave, usare un oggetto CLR normale (POCO). Gli oggetti , TableNamee PartitionKey specifici RowKeyvengono usati per provare a ottenere un'entità specifica dalla tabella.

Quando si restituiscono più entità come IEnumerable<T>, è invece possibile usare Take le proprietà e Filter per limitare il set di risultati.

Le funzioni versione 1.x non supportano il processo di lavoro isolato.

Ottenere i dati delle righe di input usando context.extraInputs.get().

Ottenere i dati delle righe di input usando context.bindings.<name> dove è il valore specificato nella <name> proprietà di name.