Azure Functions in C#: Create Your First Function Using Visual Studio

Azure Functions is a serverless computing service provided by Microsoft Azure that allows developers to execute code without managing the underlying infrastructure. It enables you to build event-driven applications that run in response to events such as HTTP requests, timer schedules, messages, and changes in data sources.

In this article, we will learn how to create your first Azure Function using Visual Studio and C#. We will walk through the process of setting up an Azure Functions project, implementing the function logic, running and testing the function locally, and deploying it to Azure.

Whether you are a beginner exploring serverless computing or a .NET developer looking to build cloud-based applications, this step-by-step tutorial will help you understand the fundamentals of Azure Functions and get started with your first function.

Getting Started

In this tutorial, we will use Visual Studio to create, implement, and test an Azure Function locally before deploying it to Azure. The exact project template and prerequisites may vary depending on the Azure Functions runtime and .NET version you choose.

Prerequisites

Before creating your first Azure Function using Visual Studio, make sure you have the following tools and resources installed or configured:

Visual Studio: Install Visual Studio 2022 or a compatible version that supports Azure Functions development.
Azure Development Workload: During Visual Studio installation, select the Azure development workload to get the tools required for developing and deploying Azure Functions.
.NET SDK: Install the .NET SDK version compatible with your selected Azure Functions runtime and project template.
Azure Functions Core Tools: Install Azure Functions Core Tools if required by your development setup to run and debug functions locally.
Azure Subscription: An Azure subscription is required to create and deploy your function to Azure. You can use a free Azure account if eligible.
Basic C# Knowledge: Familiarity with C# and basic .NET programming will help you understand the function implementation.

Basic Components of Azure Functions

Before creating your first Azure Function using Visual Studio, it is important to understand the basic components of Azure Functions and how they work together.

Function: A function is a unit of code that performs a specific task when triggered by an event. You can write the function logic in C# and use it to process HTTP requests, execute scheduled jobs, handle messages, or perform other operations.
For example, an HTTP-triggered function can receive a request from a client and return a response.
Trigger: A trigger defines the event that causes an Azure Function to execute. Every Azure Function must have exactly one trigger.
Common Azure Functions triggers include:
- HTTP Trigger: Executes when an HTTP request is received.
- Timer Trigger: Executes according to a predefined schedule.
- Blob Storage Trigger: Executes when changes occur to a configured blob.
- Queue Storage Trigger: Executes when a message is added to an Azure Storage queue.
- Service Bus Trigger: Executes when a message is available in an Azure Service Bus entity.
- Event Hub Trigger: Executes when events are received from Azure Event Hubs.
The trigger you choose depends on when and how you want your function to run.
Bindings: Bindings provide a convenient way to connect an Azure Function to other services without writing all the integration code yourself.
There are two main types of bindings:
- Input Binding: Reads data from an external service and makes it available to the function.
- Output Binding: Sends data from the function to an external service.
For example, a function can use a queue trigger to receive a message and an output binding to write the processed result to another queue.

Bindings are optional, and not every function needs them.
Function App: A Function App is the Azure resource that hosts and manages one or more Azure Functions. Functions within the same Function App share configuration, deployment, and hosting resources.
For example, you could create a Function App containing:
- An HTTP-triggered function to retrieve customer information.
- A timer-triggered function to generate daily reports.
- A queue-triggered function to process background tasks.
Azure Functions Runtime: The Azure Functions runtime manages function execution. It handles trigger processing, coordinates bindings, and manages the execution lifecycle of functions.
When you run your function locally through Visual Studio, the local Azure Functions runtime enables you to test the function before deploying it to Azure.
Configuration and Settings: Azure Functions uses configuration settings to manage application behavior and external service connections.
Common configuration files and settings include:
- host.json: Contains configuration settings that apply to the Function App and its runtime.
- local.settings.json: Stores local development settings, including environment variables and connection strings. This file is intended for local use and is not automatically published as application settings.
- Application settings in Azure: Store configuration values and environment-specific settings for the deployed Function App.
Avoid committing secrets or sensitive connection strings to source control.
Azure Storage Account: Depending on the hosting plan and features used, Azure Functions requires an Azure Storage account for runtime operations such as managing keys, coordinating triggers, and supporting certain scaling behaviors.
The storage account requirements vary by hosting plan and function capabilities. Durable Functions and other extensions may also require storage resources for their own operations.

How these components work together

Trigger: An event occurs, such as an HTTP request or timer schedule.
Azure Function: Executes your C# business logic.
Bindings (optional): Read input from or write output to connected services.

The Function App hosts the function, while the Azure Functions runtime manages execution. Configuration settings and any required storage resources support the application's operation.

Create an Azure Functions Project in Visual Studio

Now that we understand the basic components of Azure Functions, let's create our first Azure Functions project using Visual Studio and C#.

In this tutorial, we will use the .NET isolated worker model, which runs function code in a separate process from the Azure Functions runtime. This model supports dependency injection, middleware, and flexible application configuration.

Follow the steps below to create the project.

Step 1: Open Visual Studio

Open Visual Studio 2022 or a compatible version that supports the Azure Functions project template.

From the Visual Studio start window, select Create a new project.

Step 2: Select the Azure Functions Project Template

In the Create a new project window, search for Azure Functions.
Select the Azure Functions project template.
Click Next.

Make sure you select the Azure Functions template rather than a regular Console App or ASP.NET Core Web API project.

Step 3: Configure the Project

Enter the following project details:

Project name: MyFirstAzureFunction
Location: Choose the folder where you want to store the project.
Solution name: MyFirstAzureFunction

Click Next to continue.

Step 4: Configure the Azure Functions Project

On the additional configuration screen, select the following options where available:

Worker model: .NET Isolated
Target framework: Choose a supported .NET version compatible with your installed Visual Studio and Azure Functions tools.
Function: Select a trigger, such as HTTP trigger, for this tutorial.
Authorization level: Select Anonymous for a simple local demonstration, or choose an appropriate authorization level for your requirements.

Click Create to generate the project.

The available target frameworks and configuration options depend on your installed Visual Studio version and Azure Functions tooling.

Step 5: Review the Generated Project

After Visual Studio creates the project, review the generated files. Depending on the template and tooling version, you will typically see files such as:

Program.cs: Configures and starts the isolated worker application.
MyFirstAzureFunction.cs: Contains the generated function class and its trigger configuration. The actual filename may differ.
host.json: Contains settings for the Azure Functions host.
local.settings.json: Stores local development settings, including environment variables used when running the function locally.
Project file (.csproj): Defines the target framework, package references, and other project configuration.

The generated function class contains a method decorated with the [Function] attribute. Its trigger attribute specifies the event that invokes the function.

Step 6: Prepare the Project for Implementation

Once the project is created, open the generated function class and examine the function method.

For an HTTP-triggered function, the generated code typically accepts an HTTP request and returns an HTTP response. We will use this method to implement our first function's logic in the next section.

Important configuration details

Microsoft's current Visual Studio guidance uses the .NET isolated worker model and recommends selecting a supported long-term-support framework, such as .NET 8 where available in the installed template. The HTTP trigger with Anonymous authorization is convenient for a basic demonstration, but it should not be used for publicly deployed endpoints without considering security.

Implement Your First Azure Function in C#

Now that your project is set up, it’s time to write the actual code. When you created the project, Visual Studio generated a default function template (usually named Function1.cs). We will modify this template to create a simple HTTP-triggered function that accepts a name and returns a personalized greeting.

Open your Function1.cs file, delete the boilerplate code, and replace it with the following implementation:

</> C#
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;
namespace MyFirstAzureFunction
{
  public class GreetingFunction
  {
    private readonly ILogger<GreetingFunction> _logger;
    // Dependency injection is supported out-of-the-box
    public GreetingFunction(ILogger<GreetingFunction> logger)
    {
      _logger = logger;
    }
    [Function("GetGreeting")]
    public IActionResult Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequest req)
    {
      _logger.LogInformation("C# HTTP trigger function processed a request.");
      // Extract the 'name' parameter from the query string
      string name = req.Query["name"];
      if (string.IsNullOrEmpty(name))
      {
        return new BadRequestObjectResult("Please pass a name on the query string.");
      }
      return new OkObjectResult($"Hello, {name}. Welcome to Azure Functions in C#!");
    }
  }
}

How It Works

[Function("GetGreeting")]: This attribute declares the method as an Azure Function and sets its execution name. This name must be unique within your function app.
[HttpTrigger(...)]: This attribute defines the invocation type and configures the function to respond to HTTP requests.
- AuthorizationLevel.Function: Requires a function key when hosted in Azure, helping protect the function from unauthorized access.
- "get", "post": Restricts the function to accept only HTTP GET and POST requests.
HttpRequest req: Provides access to the incoming HTTP request, including its payload, headers, and query parameters.
ILogger: Enables you to write application logs for monitoring and troubleshooting. When Application Insights is configured, these logs can be collected and analyzed there.
IActionResult: Represents the HTTP response returned by the function. It allows you to use standard ASP.NET Core response types, such as OkObjectResult (HTTP 200) and BadRequestObjectResult (HTTP 400).

Testing Your Azure Function Locally

Before deploying your function to the cloud, you can run and test it completely on your local machine. Visual Studio uses the Azure Functions Core Tools to simulate the Azure environment locally.

Press F5 or click the Start/Debug button in Visual Studio.
The Azure Functions Core Tools console window will open.
Wait for the runtime to compile your code and display the local endpoint URL. It will look like this:
```
</> Plain Text
      Http Functions: GetGreeting: [GET,POST] http://localhost:7071/api/GetGreeting
```
Copy the local URL from the console: http://localhost:7071/api/GetGreeting.
Paste the URL into your browser's address bar.
Initially, you will see a 400 Bad Request error because no name was provided.

Append a query string parameter to the URL:

</> Plain Text
      http://localhost:7071/api/GetGreeting?name=Developer

Press Enter. You should see the following successful plain-text response:

</> Plain Text
      Hello, Developer. Welcome to Azure Functions in C#!

Deploying Your Azure Function to the Azure Portal

Once you have verified that your function runs perfectly on your local machine, the final step is to deploy it to the cloud. We will create the required infrastructure directly in the Azure Portal and publish our code.

Create the Function App Infrastructure in Azure

Before uploading your code, you must provision a hosting environment in the cloud.

Sign in to the Azure Portal.
Click Create a resource on the home page, search for Function App, and click Create.
Configure the Basics tab with the following settings:
- Subscription: Select your active Azure subscription.
- Resource Group: Click Create new and provide a name, such as rg-myfirstazurefunction.
- Function App Name: Enter a globally unique name, such as my-first-csharp-function.
- Hosting Option: Choose Consumption (Serverless) for a cost-effective, auto-scaling environment.
Configure the Runtime Stack options based on the programming model used in your project:
- Runtime Stack: .NET
- Version: Select your target .NET version, such as .NET 8 LTS or .NET 9, if supported by the selected hosting configuration.
- Operating System: Choose Windows or Linux. Windows can be convenient when deploying from Visual Studio.
Click Review + create, and then click Create. Wait a few minutes for the deployment to finish.

Publish Your Code from Visual Studio

Visual Studio provides a built-in publishing wizard that securely authenticates with your Azure account and uploads your compiled code.

In Visual Studio's Solution Explorer, right-click your project and select Publish....
In the publishing wizard, choose Azure as the target and click Next.
Select Azure Function App (Windows) or Azure Function App (Linux), depending on the operating system you selected in the Azure Portal. Click Next.
Sign in to your Azure account if prompted. Select your subscription, expand the appropriate resource group, and select the Function App you created in the previous step.
Click Finish. Visual Studio will generate a publishing profile for your project.
Click the prominent Publish button on the publishing summary screen to deploy your Azure Function to Azure.

Watch the Output window. Once it says Publish Succeeded, your function is officially live in the cloud.

Test the Live Function in the Portal

Return to the Azure Portal and navigate to your newly created Function App resource.
In the left-hand menu, navigate to Functions and open the Functions list.
You should see your function listed, such as GetGreeting. Click its name.
Open Code + Test, or click Get Function URL if that option is available.
Copy the function's URL. It may contain a security token (code=...) that authorizes access to your function:
```
https://<your-app-name>.azurewebsites.net/api/GetGreeting?code=xyz...
```
Paste the URL into your browser's address bar. Append &name=CloudUser to the end of the URL, then press Enter to execute your deployed Azure Function.

Summary

In this article, we explored how to create your first Azure Function using C# and Visual Studio with the .NET isolated worker model. We covered the prerequisites, project creation, basic components of an Azure Function, implementing the function logic, and testing the function locally.

Azure Functions provides a serverless computing platform that allows developers to execute code without managing the underlying infrastructure. By using C# and Visual Studio, you can build, debug, and test functions efficiently while taking advantage of Azure's scalability and integration capabilities.

As a next step, you can deploy your Azure Function to Azure, configure application settings, and explore different triggers, such as Timer, Queue, Blob Storage, and Azure Service Bus triggers, to handle various business scenarios.

With these fundamentals in place, you are ready to start building serverless applications using Azure Functions and C#.

Thanks