Configuring Triggers and Bindings in Azure Functions for a C# Class Library

3 min readJust now

Azure Functions is a serverless computing service that lets you run event-driven code without managing infrastructure. When you create an Azure Functions app as a C# class library, configuring triggers and bindings is crucial to defining how your functions respond to events and interact with other services.

Understanding Triggers and Bindings

Triggers: A trigger is what causes a function to execute. It defines the entry point for the function and specifies the type of event that will invoke it. Examples include HTTP requests, messages on a queue, or a timer.
Bindings: Bindings provide a way to declaratively connect your function to other resources like storage, databases, and messaging systems. There are input bindings (data your function consumes) and output bindings (data your function produces).

Here’s how you can configure triggers and bindings when using a C# class library for your Azure Functions app.

Step 1: Install Required NuGet Packages

To get started, you need to install the necessary NuGet packages:

Install-Package Microsoft.NET.Sdk.Functions

This package contains the tools and libraries needed for Azure Functions development.

Step 2: Define a Function Class

Each function is implemented as a public method in a class. Use the FunctionName attribute to designate a method as a function. The triggers and bindings are defined using attributes on the method parameters.

Below is an example of configuring a function with an HTTP trigger and an output binding to Azure Table Storage:

using System.IO;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

public static class MyFunctions
{
    [FunctionName("HttpTriggerFunction")]
    public static IActionResult Run(
        [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
        [Table("MyTable", Connection = "AzureWebJobsStorage")] out dynamic tableOutput,
        ILogger log)
    {
        log.LogInformation("C# HTTP trigger function processed a request.");

        string requestBody = new StreamReader(req.Body).ReadToEnd();
        var data = JsonConvert.DeserializeObject<dynamic>(requestBody);

        tableOutput = new { PartitionKey = "Partition", RowKey = Guid.NewGuid().ToString(), Data = data };

        return new OkObjectResult("Data saved to table storage.");
    }
}

Step 3: Configure Triggers

HTTP Trigger: The HttpTrigger attribute specifies that this function responds to HTTP requests. You can define the HTTP methods (get, post, etc.) and authorization level.

Queue Trigger: If you want the function to respond to messages in an Azure Storage Queue, use the QueueTriggerattribute:

[FunctionName("QueueTriggerFunction")]
public static void Run(
    [QueueTrigger("myqueue", Connection = "AzureWebJobsStorage")] string queueItem,
    ILogger log)
{
    log.LogInformation($"Queue trigger function processed: {queueItem}");
}

Timer Trigger: For scheduling tasks, use the TimerTrigger attribute:

[FunctionName("TimerTriggerFunction")]
public static void Run(
    [TimerTrigger("0 */5 * * * *")] TimerInfo timer,
    ILogger log)
{
    log.LogInformation($"Timer trigger function executed at: {DateTime.Now}");
}

Step 4: Configure Bindings

You can define bindings using attributes such as Blob, Queue, Table, or CosmosDB.

Blob Input Binding:

[FunctionName("BlobInputFunction")]
public static void Run(
    [BlobTrigger("mycontainer/{name}", Connection = "AzureWebJobsStorage")] Stream myBlob,
    string name,
    ILogger log)
{
    log.LogInformation($"Blob trigger function processed blob
     Name: {name}
     Size: {myBlob.Length} Bytes");
}

CosmosDB Binding:

[FunctionName("CosmosDBFunction")]
public static void Run(
    [CosmosDB(
        databaseName: "MyDatabase",
        collectionName: "MyCollection",
        ConnectionStringSetting = "CosmosDBConnection",
        Id = "{id}",
        PartitionKey = "{partitionKey}")] dynamic cosmosItem,
    ILogger log)
{
    log.LogInformation($"Cosmos DB item: {cosmosItem}");
}

Step 5: Configure Connection Strings

Connection strings for bindings are typically stored in the local.settings.json file for local development and in Azure App Settings for deployment:

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "<StorageConnectionString>",
    "FUNCTIONS_WORKER_RUNTIME": "dotnet"
  }
}

Step 6: Test Locally

Run your project locally using Visual Studio or the Azure Functions Core Tools. Make sure the local.settings.jsonfile has the required connection strings and configurations.

Step 7: Deploy to Azure

When your functions are tested and ready, deploy them to Azure using one of the following methods:

Visual Studio publish option
Azure CLI
GitHub Actions or Azure DevOps for CI/CD

Conclusion

Configuring triggers and bindings in Azure Functions for a C# class library involves defining them through attributes and managing their connections through configuration settings. By using the examples above, you can handle various event-driven scenarios and integrate seamlessly with Azure services.