Develop C# class library functions using Azure Functions

This article is an introduction to developing Azure Functions by using C# in .NET class libraries.


This article supports .NET class library functions that run in-process with the runtime. Functions also supports .NET 5.x by running your C# functions out-of-process and isolated from the runtime. To learn more, see .NET isolated process functions.

As a C# developer, you may also be interested in one of the following articles:

Getting started Concepts Guided learning/samples

Azure Functions supports C# and C# script programming languages. If you're looking for guidance on using C# in the Azure portal, see C# script (.csx) developer reference.

Supported versions

Versions of the Functions runtime work with specific versions of .NET. To learn more about Functions versions, see Azure Functions runtime versions overview. Version support depends on whether your functions run in-process or out-of-process (isolated).

The following table shows the highest level of .NET Core or .NET Framework that can be used with a specific version of Functions.

Functions runtime version In-process
(.NET class library)
(.NET Isolated)
Functions 4.x (Preview) .NET 6.0 (preview) .NET 6.0 (preview)2
Functions 3.x .NET Core 3.1 .NET 5.0
Functions 2.x .NET Core 2.11 n/a
Functions 1.x .NET Framework 4.8 n/a

1 For details, see Functions v2.x considerations.
2 You can currently only create isolated process functions by using Azure Functions Core Tools. To learn more, see Quickstart: Create a C# function in Azure from the command line.

For the latest news about Azure Functions releases, including the removal of specific older minor versions, monitor Azure App Service announcements.

Functions v2.x considerations

Function apps that target the latest 2.x version (~2) are automatically upgraded to run on .NET Core 3.1. Because of breaking changes between .NET Core versions, not all apps developed and compiled against .NET Core 2.2 can be safely upgraded to .NET Core 3.1. You can opt out of this upgrade by pinning your function app to ~2.0. Functions also detects incompatible APIs and may pin your app to ~2.0 to prevent incorrect execution on .NET Core 3.1.


If your function app is pinned to ~2.0 and you change this version target to ~2, your function app may break. If you deploy using ARM templates, check the version in your templates. If this occurs, change your version back to target ~2.0 and fix compatibility issues.

Function apps that target ~2.0 continue to run on .NET Core 2.2. This version of .NET Core no longer receives security and other maintenance updates. To learn more, see this announcement page.

You should work to make your functions compatible with .NET Core 3.1 as soon as possible. After you've resolved these issues, change your version back to ~2 or upgrade to ~3. To learn more about targeting versions of the Functions runtime, see How to target Azure Functions runtime versions.

When running on Linux in a Premium or dedicated (App Service) plan, you pin your version by instead targeting a specific image by setting the linuxFxVersion site config setting to DOCKER| To learn how to set linuxFxVersion, see Manual version updates on Linux.

Functions class library project

In Visual Studio, the Azure Functions project template creates a C# class library project that contains the following files:

  • host.json - stores configuration settings that affect all functions in the project when running locally or in Azure.
  • local.settings.json - stores app settings and connection strings that are used when running locally. This file contains secrets and isn't published to your function app in Azure. Instead, add app settings to your function app.

When you build the project, a folder structure that looks like the following example is generated in the build output directory:

 | - bin
 | - MyFirstFunction
 | | - function.json
 | - MySecondFunction
 | | - function.json
 | - host.json

This directory is what gets deployed to your function app in Azure. The binding extensions required in version 2.x of the Functions runtime are added to the project as NuGet packages.


The build process creates a function.json file for each function. This function.json file is not meant to be edited directly. You can't change binding configuration or disable the function by editing this file. To learn how to disable a function, see How to disable functions.

Methods recognized as functions

In a class library, a function is a static method with a FunctionName and a trigger attribute, as shown in the following example:

public static class SimpleExample
    public static void Run(
        [QueueTrigger("myqueue-items")] string myQueueItem, 
        ILogger log)
        log.LogInformation($"C# function processed: {myQueueItem}");

The FunctionName attribute marks the method as a function entry point. The name must be unique within a project, start with a letter and only contain letters, numbers, _, and -, up to 127 characters in length. Project templates often create a method named Run, but the method name can be any valid C# method name.

The trigger attribute specifies the trigger type and binds input data to a method parameter. The example function is triggered by a queue message, and the queue message is passed to the method in the myQueueItem parameter.

Method signature parameters

The method signature may contain parameters other than the one used with the trigger attribute. Here are some of the other parameters that you can include:

The order of parameters in the function signature doesn't matter. For example, you can put trigger parameters before or after other bindings, and you can put the logger parameter before or after trigger or binding parameters.

Output bindings

A function can have zero or one output bindings defined by using output parameters.

The following example modifies the preceding one by adding an output queue binding named myQueueItemCopy. The function writes the contents of the message that triggers the function to a new message in a different queue.

public static class SimpleExampleWithOutput
    public static void Run(
        [QueueTrigger("myqueue-items-source")] string myQueueItem, 
        [Queue("myqueue-items-destination")] out string myQueueItemCopy,
        ILogger log)
        log.LogInformation($"CopyQueueMessage function processed: {myQueueItem}");
        myQueueItemCopy = myQueueItem;

Values assigned to output bindings are written when the function exits. You can use more than one output binding in a function by simply assigning values to multiple output parameters.

The binding reference articles (Storage queues, for example) explain which parameter types you can use with trigger, input, or output binding attributes.

Binding expressions example

The following code gets the name of the queue to monitor from an app setting, and it gets the queue message creation time in the insertionTime parameter.

public static class BindingExpressionsExample
    public static void Run(
        [QueueTrigger("%queueappsetting%")] string myQueueItem,
        DateTimeOffset insertionTime,
        ILogger log)
        log.LogInformation($"Message content: {myQueueItem}");
        log.LogInformation($"Created at: {insertionTime}");

Autogenerated function.json

The build process creates a function.json file in a function folder in the build folder. As noted earlier, this file is not meant to be edited directly. You can't change binding configuration or disable the function by editing this file.

The purpose of this file is to provide information to the scale controller to use for scaling decisions on the Consumption plan. For this reason, the file only has trigger info, not input/output bindings.

The generated function.json file includes a configurationSource property that tells the runtime to use .NET attributes for bindings, rather than function.json configuration. Here's an example:

  "generatedBy": "Microsoft.NET.Sdk.Functions-",
  "configurationSource": "attributes",
  "bindings": [
      "type": "queueTrigger",
      "queueName": "%input-queue-name%",
      "name": "myQueueItem"
  "disabled": false,
  "scriptFile": "..\\bin\\FunctionApp1.dll",
  "entryPoint": "FunctionApp1.QueueTrigger.Run"


The function.json file generation is performed by the NuGet package Microsoft.NET.Sdk.Functions.

The same package is used for both version 1.x and 2.x of the Functions runtime. The target framework is what differentiates a 1.x project from a 2.x project. Here are the relevant parts of .csproj files, showing different target frameworks with the same Sdk package:

  <PackageReference Include="Microsoft.NET.Sdk.Functions" Version="1.0.8" />

Among the Sdk package dependencies are triggers and bindings. A 1.x project refers to 1.x triggers and bindings because those triggers and bindings target the .NET Framework, while 2.x triggers and bindings target .NET Core.

The Sdk package also depends on Newtonsoft.Json, and indirectly on WindowsAzure.Storage. These dependencies make sure that your project uses the versions of those packages that work with the Functions runtime version that the project targets. For example, Newtonsoft.Json has version 11 for .NET Framework 4.6.1, but the Functions runtime that targets .NET Framework 4.6.1 is only compatible with Newtonsoft.Json 9.0.1. So your function code in that project also has to use Newtonsoft.Json 9.0.1.

The source code for Microsoft.NET.Sdk.Functions is available in the GitHub repo azure-functions-vs-build-sdk.

Local runtime version

Visual Studio uses the Azure Functions Core Tools to run Functions projects on your local computer. The Core Tools is a command-line interface for the Functions runtime.

If you install the Core Tools using the Windows installer (MSI) package or by using npm, that doesn't affect the Core Tools version used by Visual Studio. For the Functions runtime version 1.x, Visual Studio stores Core Tools versions in %USERPROFILE%\AppData\Local\Azure.Functions.Cli and uses the latest version stored there. For Functions 2.x, the Core Tools are included in the Azure Functions and Web Jobs Tools extension. For both 1.x and 2.x, you can see what version is being used in the console output when you run a Functions project:

[3/1/2018 9:59:53 AM] Starting Host (HostId=contoso2-1518597420, Version=2.0.11353.0, ProcessId=22020, Debug=False, Attempt=0, FunctionsExtensionVersion=)


You can compile your function app as ReadyToRun binaries. ReadyToRun is a form of ahead-of-time compilation that can improve startup performance to help reduce the impact of cold-start when running in a Consumption plan.

ReadyToRun is available in .NET 3.0 and requires version 3.0 of the Azure Functions runtime.

To compile your project as ReadyToRun, update your project file by adding the <PublishReadyToRun> and <RuntimeIdentifier> elements. The following is the configuration for publishing to a Windows 32-bit function app.



ReadyToRun currently doesn't support cross-compilation. You must build your app on the same platform as the deployment target. Also, pay attention to the "bitness" that is configured in your function app. For example, if your function app in Azure is Windows 64-bit, you must compile your app on Windows with win-x64 as the runtime identifier.

You can also build your app with ReadyToRun from the command line. For more information, see the -p:PublishReadyToRun=true option in dotnet publish.

Supported types for bindings

Each binding has its own supported types; for instance, a blob trigger attribute can be applied to a string parameter, a POCO parameter, a CloudBlockBlob parameter, or any of several other supported types. The binding reference article for blob bindings lists all supported parameter types. For more information, see Triggers and bindings and the binding reference docs for each binding type.


If you plan to use the HTTP or WebHook bindings, plan to avoid port exhaustion that can be caused by improper instantiation of HttpClient. For more information, see How to manage connections in Azure Functions.

Binding to method return value

You can use a method return value for an output binding, by applying the attribute to the method return value. For examples, see Triggers and bindings.

Use the return value only if a successful function execution always results in a return value to pass to the output binding. Otherwise, use ICollector or IAsyncCollector, as shown in the following section.

Writing multiple output values

To write multiple values to an output binding, or if a successful function invocation might not result in anything to pass to the output binding, use the ICollector or IAsyncCollector types. These types are write-only collections that are written to the output binding when the method completes.

This example writes multiple queue messages into the same queue using ICollector:

public static class ICollectorExample
    public static void Run(
        [QueueTrigger("myqueue-items-source-3")] string myQueueItem,
        [Queue("myqueue-items-destination")] ICollector<string> myDestinationQueue,
        ILogger log)
        log.LogInformation($"C# function processed: {myQueueItem}");
        myDestinationQueue.Add($"Copy 1: {myQueueItem}");
        myDestinationQueue.Add($"Copy 2: {myQueueItem}");


To make a function asynchronous, use the async keyword and return a Task object.

public static class AsyncExample
    public static async Task RunAsync(
        [BlobTrigger("sample-images/{blobName}")] Stream blobInput,
        [Blob("sample-images-copies/{blobName}", FileAccess.Write)] Stream blobOutput,
        CancellationToken token,
        ILogger log)
        log.LogInformation($"BlobCopy function processed.");
        await blobInput.CopyToAsync(blobOutput, 4096, token);

You can't use out parameters in async functions. For output bindings, use the function return value or a collector object instead.

Cancellation tokens

A function can accept a CancellationToken parameter, which enables the operating system to notify your code when the function is about to be terminated. You can use this notification to make sure the function doesn't terminate unexpectedly in a way that leaves data in an inconsistent state.

The following example shows how to check for impending function termination.

public static class CancellationTokenExample
    public static void Run(
        [QueueTrigger("inputqueue")] string inputText,
        TextWriter logger,
        CancellationToken token)
        for (int i = 0; i < 100; i++)
            if (token.IsCancellationRequested)
                logger.WriteLine("Function was cancelled at iteration {0}", i);
            logger.WriteLine("Normal processing for queue message={0}", inputText);


In your function code, you can write output to logs that appear as traces in Application Insights. The recommended way to write to the logs is to include a parameter of type ILogger, which is typically named log. Version 1.x of the Functions runtime used TraceWriter, which also writes to Application Insights, but doesn't support structured logging. Don't use Console.Write to write your logs, since this data isn't captured by Application Insights.


In your function definition, include an ILogger parameter, which supports structured logging.

With an ILogger object, you call Log<level> extension methods on ILogger to create logs. The following code writes Information logs with category Function.<YOUR_FUNCTION_NAME>.User.:

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, ILogger logger)
    logger.LogInformation("Request for item with key={itemKey}.", id);

To learn more about how Functions implements ILogger, see Collecting telemetry data. Categories prefixed with Function assume you are using an ILogger instance. If you choose to instead use an ILogger<T>, the category name may instead be based on T.

Structured logging

The order of placeholders, not their names, determines which parameters are used in the log message. Suppose you have the following code:

string partitionKey = "partitionKey";
string rowKey = "rowKey";
logger.LogInformation("partitionKey={partitionKey}, rowKey={rowKey}", partitionKey, rowKey);

If you keep the same message string and reverse the order of the parameters, the resulting message text would have the values in the wrong places.

Placeholders are handled this way so that you can do structured logging. Application Insights stores the parameter name-value pairs and the message string. The result is that the message arguments become fields that you can query on.

If your logger method call looks like the previous example, you can query the field customDimensions.prop__rowKey. The prop__ prefix is added to ensure there are no collisions between fields the runtime adds and fields your function code adds.

You can also query on the original message string by referencing the field customDimensions.prop__{OriginalFormat}.

Here's a sample JSON representation of customDimensions data:

  "customDimensions": {
    "prop__{OriginalFormat}":"C# Queue trigger function processed: {message}",

Log custom telemetry

There is a Functions-specific version of the Application Insights SDK that you can use to send custom telemetry data from your functions to Application Insights: Microsoft.Azure.WebJobs.Logging.ApplicationInsights. Use the following command from the command prompt to install this package:

dotnet add package Microsoft.Azure.WebJobs.Logging.ApplicationInsights --version <VERSION>

In this command, replace <VERSION> with a version of this package that supports your installed version of Microsoft.Azure.WebJobs.

The following C# examples uses the custom telemetry API. The example is for a .NET class library, but the Application Insights code is the same for C# script.

Version 2.x and later versions of the runtime use newer features in Application Insights to automatically correlate telemetry with the current operation. There's no need to manually set the operation Id, ParentId, or Name fields.

using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;

using Microsoft.ApplicationInsights;
using Microsoft.ApplicationInsights.DataContracts;
using Microsoft.ApplicationInsights.Extensibility;
using System.Linq;

namespace functionapp0915
    public class HttpTrigger2
        private readonly TelemetryClient telemetryClient;

        /// Using dependency injection will guarantee that you use the same configuration for telemetry collected automatically and manually.
        public HttpTrigger2(TelemetryConfiguration telemetryConfiguration)
            this.telemetryClient = new TelemetryClient(telemetryConfiguration);

        public Task<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = null)]
            HttpRequest req, ExecutionContext context, ILogger log)
            log.LogInformation("C# HTTP trigger function processed a request.");
            DateTime start = DateTime.UtcNow;

            // Parse query parameter
            string name = req.Query
                .FirstOrDefault(q => string.Compare(q.Key, "name", true) == 0)

            // Write an event to the customEvents table.
            var evt = new EventTelemetry("Function called");
            evt.Context.User.Id = name;

            // Generate a custom metric, in this case let's use ContentLength.

            // Log a custom dependency in the dependencies table.
            var dependency = new DependencyTelemetry
                Name = "GET api/planets/1/",
                Target = "",
                Data = "",
                Timestamp = start,
                Duration = DateTime.UtcNow - start,
                Success = true
            dependency.Context.User.Id = name;

            return Task.FromResult<IActionResult>(new OkResult());

In this example, the custom metric data gets aggregated by the host before being sent to the customMetrics table. To learn more, see the GetMetric documentation in Application Insights.

When running locally, you must add the APPINSIGHTS_INSTRUMENTATIONKEY setting, with the Application Insights key, to the local.settings.json file.

Don't call TrackRequest or StartOperation<RequestTelemetry> because you'll see duplicate requests for a function invocation. The Functions runtime automatically tracks requests.

Don't set telemetryClient.Context.Operation.Id. This global setting causes incorrect correlation when many functions are running simultaneously. Instead, create a new telemetry instance (DependencyTelemetry, EventTelemetry) and modify its Context property. Then pass in the telemetry instance to the corresponding Track method on TelemetryClient (TrackDependency(), TrackEvent(), TrackMetric()). This method ensures that the telemetry has the correct correlation details for the current function invocation.

Environment variables

To get an environment variable or an app setting value, use System.Environment.GetEnvironmentVariable, as shown in the following code example:

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

    private static string GetEnvironmentVariable(string name)
        return name + ": " +
            System.Environment.GetEnvironmentVariable(name, EnvironmentVariableTarget.Process);

App settings can be read from environment variables both when developing locally and when running in Azure. When developing locally, app settings come from the Values collection in the local.settings.json file. In both environments, local and Azure, GetEnvironmentVariable("<app setting name>") retrieves the value of the named app setting. For instance, when you're running locally, "My Site Name" would be returned if your local.settings.json file contains { "Values": { "WEBSITE_SITE_NAME": "My Site Name" } }.

The System.Configuration.ConfigurationManager.AppSettings property is an alternative API for getting app setting values, but we recommend that you use GetEnvironmentVariable as shown here.

Binding at runtime

In C# and other .NET languages, you can use an imperative binding pattern, as opposed to the declarative bindings in attributes. Imperative binding is useful when binding parameters need to be computed at runtime rather than design time. With this pattern, you can bind to supported input and output bindings on-the-fly in your function code.

Define an imperative binding as follows:

  • Do not include an attribute in the function signature for your desired imperative bindings.

  • Pass in an input parameter Binder binder or IBinder binder.

  • Use the following C# pattern to perform the data binding.

    using (var output = await binder.BindAsync<T>(new BindingTypeAttribute(...)))

    BindingTypeAttribute is the .NET attribute that defines your binding, and T is an input or output type that's supported by that binding type. T cannot be an out parameter type (such as out JObject). For example, the Mobile Apps table output binding supports six output types, but you can only use ICollector<T> or IAsyncCollector<T> with imperative binding.

Single attribute example

The following example code creates a Storage blob output binding with blob path that's defined at run time, then writes a string to the blob.

public static class IBinderExample
    public static void Run(
        [QueueTrigger("myqueue-items-source-4")] string myQueueItem,
        IBinder binder,
        ILogger log)
        log.LogInformation($"CreateBlobUsingBinder function processed: {myQueueItem}");
        using (var writer = binder.Bind<TextWriter>(new BlobAttribute(
                    $"samples-output/{myQueueItem}", FileAccess.Write)))
            writer.Write("Hello World!");

BlobAttribute defines the Storage blob input or output binding, and TextWriter is a supported output binding type.

Multiple attributes example

The preceding example gets the app setting for the function app's main Storage account connection string (which is AzureWebJobsStorage). You can specify a custom app setting to use for the Storage account by adding the StorageAccountAttribute and passing the attribute array into BindAsync<T>(). Use a Binder parameter, not IBinder. For example:

public static class IBinderExampleMultipleAttributes
    public async static Task RunAsync(
            [QueueTrigger("myqueue-items-source-binder2")] string myQueueItem,
            Binder binder,
            ILogger log)
        log.LogInformation($"CreateBlobInDifferentStorageAccount function processed: {myQueueItem}");
        var attributes = new Attribute[]
        new BlobAttribute($"samples-output/{myQueueItem}", FileAccess.Write),
        new StorageAccountAttribute("MyStorageAccount")
        using (var writer = await binder.BindAsync<TextWriter>(attributes))
            await writer.WriteAsync("Hello World!!");

Triggers and bindings

This table shows the bindings that are supported in the major versions of the Azure Functions runtime:

Type 1.x 2.x and higher1 Trigger Input Output
Blob storage
Azure Cosmos DB
Event Grid
Event Hubs
HTTP & webhooks
IoT Hub
Mobile Apps
Notification Hubs
Queue storage
Service Bus
Table storage

1 Starting with the version 2.x runtime, all bindings except HTTP and Timer must be registered. See Register binding extensions.

2 Triggers aren't supported in the Consumption plan. Requires runtime-driven triggers.

3 Supported only in Kubernetes, IoT Edge, and other self-hosted modes only.

Next steps