Azure Functions Queue Storage Output Bindings (C#)

This article explains how to use the Queue Storage output binding with Azure Functions written in C#. This binding allows your function to write messages to an Azure Queue Storage queue.

Binding Configuration

The Queue Storage output binding is configured in the function.json file (for v1 and v2 programming models) or via attributes in your C# code (for v3 and later programming models).

function.json (v1/v2 Model)

The following is an example of a function.json configuration for an output binding:

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "msg",
      "type": "queue",
      "direction": "out",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

Properties:

• name: The name of the variable that represents the output binding in your code.
• type: Must be set to queue.
• direction: Must be set to out.
• queueName: The name of the queue to which messages will be written. If the queue does not exist, it will be created.
• connection: The name of an app setting that contains the queue storage connection string. Defaults to AzureWebJobsStorage.

C# Attributes (v3+ Model)

In the C# v3+ programming model, you use attributes to define bindings.

The Microsoft.Azure.WebJobs.QueueAttribute attribute is used to configure the output binding. You can also use Microsoft.Azure.WebJobs.Storage.Queue.IAsyncCollector<string> or Microsoft.Azure.WebJobs.Storage.Queue.ICollector<string> as the parameter type.

using Microsoft.Azure.WebJobs;

            public static class QueueOutputFunction
            {
                [FunctionName("QueueOutputTrigger")]
                public static void Run(
                    [QueueTrigger("inqueue")] string myQueueItem,
                    [Queue("outqueue", Connection = "AzureWebJobsStorage")] out string outputQueueItem)
                {
                    outputQueueItem = $"Message added to output queue: {myQueueItem}";
                    // Log any additional information if needed
                }
            }
            

Alternatively, you can use IAsyncCollector for asynchronous operations:

using Microsoft.Azure.WebJobs;
            using Microsoft.Azure.WebJobs.Extensions.Storage; // For IAsyncCollector
            using System.Threading.Tasks;

            public static class QueueOutputAsyncFunction
            {
                [FunctionName("QueueOutputAsyncTrigger")]
                public static async Task Run(
                    [QueueTrigger("inqueue-async")] string myQueueItem,
                    [Queue("outqueue-async", Connection = "AzureWebJobsStorage")] IAsyncCollector<string> outputQueueItem)
                {
                    await outputQueueItem.AddAsync($"Asynchronous message to output queue: {myQueueItem}");
                }
            }
            

Example: Writing to a Queue

Consider a function that is triggered by a message on an inqueue and writes a modified message to an outqueue. This is a common pattern for message processing pipelines.

C# Code (v3+ Model)

using Microsoft.Azure.WebJobs;
            using Microsoft.Extensions.Logging;

            public static class ProcessMessageAndOutput
            {
                [FunctionName("ProcessMessageAndOutput")]
                public static void Run(
                    [QueueTrigger("requests", Connection = "AzureWebJobsStorage")] string requestMessage,
                    [Queue("responses", Connection = "AzureWebJobsStorage")] out string responseMessage,
                    ILogger log)
                {
                    log.LogInformation($"Processing request: {requestMessage}");

                    // Process the request message...
                    string processedData = requestMessage.ToUpper();

                    // Create the response message
                    responseMessage = $"Processed: {processedData}";

                    log.LogInformation($"Response sent to queue: {responseMessage}");
                }
            }
            

In this example:

• The function is triggered by messages in the requests queue.
• The requestMessage parameter receives the content of the queue message.
• The responseMessage parameter, defined with out and the Queue attribute, will send a message to the responses queue.
• The Connection property specifies the app setting that holds the connection string for Azure Storage.

Handling Different Data Types

By default, the Queue Storage output binding handles strings. If you need to send complex objects, you can serialize them to JSON strings before sending them to the queue.

Example: Sending a JSON Object

using Microsoft.Azure.WebJobs;
            using Microsoft.Extensions.Logging;
            using Newtonsoft.Json; // Make sure to add the Newtonsoft.Json NuGet package

            public class CustomMessage
            {
                public string Id { get; set; }
                public string Payload { get; set; }
            }

            public static class SendJsonObjectFunction
            {
                [FunctionName("SendJsonObjectFunction")]
                public static void Run(
                    [QueueTrigger("input-json")] string inputJson,
                    [Queue("output-json", Connection = "AzureWebJobsStorage")] out string outputJson,
                    ILogger log)
                {
                    log.LogInformation($"Received JSON: {inputJson}");

                    var messageObject = JsonConvert.DeserializeObject<CustomMessage>(inputJson);

                    // Modify the object
                    messageObject.Payload = messageObject.Payload.ToUpper();

                    // Serialize back to JSON for sending to the output queue
                    outputJson = JsonConvert.SerializeObject(messageObject);

                    log.LogInformation($"Sending JSON to output queue: {outputJson}");
                }
            }
            

Key Considerations

• Connection Strings: Always store your Azure Storage connection strings in application settings (e.g., AzureWebJobsStorage) and not directly in your code.
• Queue Creation: If the specified output queue does not exist, Azure Functions will attempt to create it.
• Message Size: Standard Azure Queue Storage messages have a maximum size of 64 KB. For larger messages, consider using Blob Storage.
• Idempotency: Design your functions to be idempotent, meaning that processing the same message multiple times has the same effect as processing it once. This is crucial for reliable message processing.

This article provides a comprehensive overview of using Queue Storage output bindings in Azure Functions with C#. Refer to the official Azure documentation for more advanced configurations and scenarios.