Azure Functions in C#: HTTP Triggers and Serverless APIs

Introduction

Azure Functions is a serverless service in Microsoft Azure that allows developers to execute code without managing the underlying servers.

Instead of continuously running an application or managing virtual machines, developers define functions that execute when a specific event occurs. The event can be an HTTP request, a file upload, a scheduled timer, or another supported trigger.

Azure manages the underlying infrastructure and can scale function execution according to workload and the selected hosting plan.

Azure Functions are commonly used for:

Background processing
Lightweight APIs
Data processing
Automation tasks
Scheduled jobs
File-processing workflows
Notifications and integrations

Azure Functions supports multiple programming languages, including C#, JavaScript, Python, and Java. For .NET developers, C# is a common choice for implementing Azure Functions.

How Azure Functions Work

The basic execution model is event-driven:

Event
  |
  v
Azure Function Trigger
  |
  v
Function Code
  |
  v
Process Request
  |
  v
Return Result

For example, with an HTTP trigger:

Client
  |
  | HTTP Request
  v
Azure Function
  |
  | Execute C# Code
  v
HTTP Response

The developer focuses on the function's application logic, while Azure handles the infrastructure required to execute it.

Example: Simple Azure Function with an HTTP Trigger

The following example creates an HTTP-triggered Azure Function using C#:

using System.Net;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;

public class HelloFunction
{
    [Function("HelloFunction")]
    public HttpResponseData Run(
        [HttpTrigger(
            AuthorizationLevel.Anonymous,
            "get")] HttpRequestData req)
    {
        var response =
            req.CreateResponse(HttpStatusCode.OK);

        response.WriteString(
            "Hello from Azure Functions!");

        return response;
    }
}

Understanding the Azure Function

Function Attribute

The following attribute identifies the method as an Azure Function:

[Function("HelloFunction")]

The function is named HelloFunction.

HTTP Trigger

The HTTP trigger is defined using:

[HttpTrigger(
    AuthorizationLevel.Anonymous,
    "get")]

This means the function can be triggered by an HTTP GET request.

The trigger also specifies an authorization level. In this example, it is:

AuthorizationLevel.Anonymous

This is useful for a simple demonstration, but production APIs should use an appropriate authentication and authorization strategy.

Request and Response

The function receives an HttpRequestData object:

HttpRequestData req

It creates an HTTP response using:

var response =
    req.CreateResponse(HttpStatusCode.OK);

The function then writes the response message:

response.WriteString(
    "Hello from Azure Functions!");

Finally, it returns the response:

return response;

How the HTTP Trigger Executes

When a client sends an HTTP GET request to the function endpoint, Azure Functions invokes the Run method.

The execution flow is:

1. Client sends HTTP GET request
              |
              v
2. HTTP trigger receives request
              |
              v
3. Azure Functions invokes Run()
              |
              v
4. C# code executes
              |
              v
5. Function creates HTTP 200 response
              |
              v
6. Client receives the response

The response body is:

Hello from Azure Functions!

Common Azure Functions Use Cases

Background Processing

Functions can process work independently from the main application.

For example, an application can trigger background processing after an event occurs.

Sending Emails and Notifications

A function can be triggered by an application event and perform notification-related work such as sending emails or processing notification requests.

File Processing

A function can respond to files being uploaded to supported Azure storage services.

For example:

File Upload
     |
     v
Storage Event
     |
     v
Azure Function
     |
     v
Process File

This can be useful for tasks such as processing uploaded documents or images.

Scheduled Jobs

Timer-based functions can execute code according to a configured schedule.

They can be used for tasks such as:

Scheduled data processing
Cleanup operations
Periodic synchronization
Automated maintenance tasks

Lightweight APIs

HTTP-triggered Azure Functions can expose endpoints for relatively small API operations without requiring a continuously running web server managed by the developer.

Serverless Benefits

One of the main benefits of Azure Functions is the serverless execution model.

Developers can focus primarily on application logic instead of managing the underlying server infrastructure.

Other benefits include:

Event-driven execution
Automatic infrastructure management
Support for multiple programming languages
Integration with Azure services
Ability to scale according to the selected hosting configuration
Consumption-based pricing options for supported hosting plans

The exact scaling behavior and billing model depend on the Azure Functions hosting plan being used.

Azure Functions and C#

For .NET developers, Azure Functions provides a natural way to run C# code in response to events.

A typical application might combine Azure Functions with other Azure services:

                   Azure Application
                          |
          +---------------+---------------+
          |               |               |
       HTTP API       Storage Event     Timer
          |               |               |
          v               v               v
      Function         Function         Function
          |               |               |
          +---------------+---------------+
                          |
                          v
                   Azure Services

This event-driven approach is useful when application operations can be separated into independent functions.

Conclusion

Azure Functions provides a serverless, event-driven execution model for running application code without requiring developers to manage the underlying server infrastructure directly.

With an HTTP trigger, a C# function can act as a lightweight API endpoint that receives a request, executes application logic, and returns an HTTP response.

Beyond HTTP APIs, Azure Functions can be used for background processing, file processing, scheduled jobs, notifications, automation, and integrations.

For .NET developers, C# and Azure Functions provide a practical combination for building event-driven workloads in Azure.