How to get application settings for your Azure Function App using C#?

This article explains how you can access an Azure Function's Application/Environment settings/variables from your C# code. Different versions of Azure Functions have different ways to access the Azure Function settings, but this page should explain the easiest way to get your application setting values for each Azure Functions version!

While this is something I need often, it has been another little thing, that I always forget - so better document it somewhere.

How to get application settings in different runtime versions of Azure Functions?

This has changed between different versions of Azure Functions runtime - so I'm describing what should work for v4 (the latest runtime version), v3, v2, and v1.

Note, that a lot of the examples below are not entirely specific to Azure Functions - they show how to access app.config or local.settings.json values in C# regardless of the exact implementation, whether it's a webjob, ASP.NET application, .NET Console program, or something else. This post is written from Azure Functions' viewpoint, though.

Accessing the settings in Azure Functions Runtime Versions 3 & 4

Okay, so if you'll take a look at the way the Application Settings (or whatever you want to call them) are accessed for the v2 runtime of Azure Functions, you can see they made it extremely granular. It's very functional, but it can be a bit of a pain in the behind when just setting up one function.

Now, in v3 they made it far more straightforward! And luckily, they kept this configuration for v4 as well.

The example below shouldn't require any NuGet packages, and it just works!

Awesome! Just update your using statements like shown:

// C# ConfigurationBuilder example for Azure Functions v3 or v4 runtime
using System;
using System.IO;

// you'll need this:
using Microsoft.Extensions.Configuration; 

namespace YourApp
{
 public static class YourClass
 {
    
  [FunctionName("FunctionName")]
  public static async Task<IActionResult> Run(
   [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
   // You'll need this to add the 
   // local.settings.json file for local execution:
   ExecutionContext context, 
   ILogger log)
  {
   var config = new ConfigurationBuilder()
   .SetBasePath(context.FunctionAppDirectory)
   // This gives you access to your application settings 
   // in your local development environment
   .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true) 
   // This is what actually gets you the 
   // application settings in Azure
   .AddEnvironmentVariables() 
   .Build();
        
   string appsettingvalue = config["appsettingkey"];

  }
 }
}

Remember to add the ExecutionContext as an injection to your Azure Function.

This piece of code fetches the configuration keys and values from Environment Variables, and a local file called "local.settings.json". This file is typically added to your Visual Studio Azure Functions project when it was first created. However, if you're jumping on a project that was created by someone else, they might have .gitignore'd the configuration file (as they probably should), so you didn't get the file.

And what should your local.settings.json file look like? Something like below:

{
  "IsEncrypted": false,
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;..."
  },
  "Values": {
    "appsettingkey":  "value" 
  }
}

And with that, you should be good in Azure Functions v3.

Accessing the settings in Azure Functions Runtime Version 2

For the second generation of Azure Functions, the code to access the Application Settings is the same, but the configuration steps are a bit different. Not quite as straightforward as v1 (you'll see that further below) or superbly easy as v3 (above), but flexible for sure.

ConfigurationManager is not used like in v1. Instead, you're supposed to use ConfigurationBuilder. Check out the code example below!

// C# ConfigurationBuilder example for Azure Functions v2 runtime
using System;
using System.IO;

using Microsoft.Extensions.Configuration; // <- you'll need this

namespace YourApp
{
 public static class YourClass
 {
	
 [FunctionName("FunctionName")]
 public static async Task<IActionResult> Run(
  [HttpTrigger(
   AuthorizationLevel.Anonymous, 
   "post", 
   Route = null)] HttpRequest req,
  // You'll need this to add the local.settings.json 
  // file for local execution:
  ExecutionContext context, 
  ILogger log)
 {
  var config = new ConfigurationBuilder()
   .SetBasePath(context.FunctionAppDirectory)
   // This gives you access to your application settings
   // in your local development environment:
   .AddJsonFile("local.settings.json", optional: true, reloadOnChange: true)
   // This is what actually gets you the application settings in Azure
   .AddEnvironmentVariables() 
   .Build();
				
   string appsettingvalue = config["appsettingkey"];

  }
 }
}

Just like v3. Good stuff.

However, you won't only need to add a reference to Microsoft.Extensions.Configuration and a new parameter "ExecutionContext context" to your function - see below:

using Microsoft.Extensions.Configuration;

namespace YourNamespace
{
 public static class YourClass
 {
  [FunctionName("FunctionName")]
  public static async Task RunAsync(
   [HttpTrigger(
    AuthorizationLevel.Anonymous, 
    "get", 
    "post", 
    Route = null)]HttpRequest req,
   TraceWriter log, 
   ExecutionContext context)
  {
   // omitted for clarity
  }
 }
}

You might also need to add a NuGet package for Microsoft.Extensions.Configuration - should be easy enough!

However, with v2 your configuration might not quite be done yet.

Your error might be something like this:

Error CS1061

'IConfigurationBuilder' does not contain a definition for 'AddEnvironmentVariables' and no accessible extension method 'AddEnvironmentVariables' accepting a first argument of type 'IConfigurationBuilder' could be found (are you missing a using directive or an assembly reference?)

If you get an error for .SetBasePath(), .AddJsonFile() or .AddEnvironmentVariables(), basically just add more NuGet packages until the issue is resolved 😅 Sounds confusing, but the different configuration options are now really granular - so you'll need a few packages. I have listed them below...

There are a lot of NuGet packages to help you out! Start with these:

• SetBasePath() requires:
  • Microsoft.Extensions.Configuration.Abstractions
• AddJsonFile() requires:
  • Microsoft.Extensions.Configuration.FileExtensions
  • Microsoft.Extensions.Configuration.Json
• AddEnvironmentVariables() requires:
  • Microsoft.Extensions.Configuration.EnvironmentVariables and possibly
  • Microsoft.Extensions.Configuration.UserSecrets

This rather granular approach to configurations might optimize the size and performance of the resulting software package, but it does make parts of the development cycle just a bit frustrating :)

Accessing the settings in Azure Functions Runtime Version 1

The 1.x generation of Azure Functions SDK uses the very traditional ConfigurationManager for accessing the Environmental variables or Application Settings. This example below shows how you can, for example, fetch the client id, client secret, and Azure AD domain information for use later in the code:

// C# ConfigurationManager example for Azure Functions v1 runtime
var clientId = System.Configuration.ConfigurationManager.AppSettings["ClientId"];
var clientSecret = System.Configuration.ConfigurationManager.AppSettings["ClientSecret"];
var aadDomain = System.Configuration.ConfigurationManager.AppSettings["AADDomain"];

Nice and easy! ConfigurationManager is the good-old way of getting your hands on the settings. It exposes AppSettings, which is just a NameValueCollection - with a key (or "name"), you get back a string-typed value.

In a production workload, you might want to consider using Azure Key Vault instead of the app settings - but that's a topic for another article!

Accessing the settings in Azure Functions Runtime Versions 1 & 2 for .NET Core < 2.0

While you look at the model for managing the configurations in v2, and if you're not on v3 yet, you might think adding a dozen NuGet packages looks like a bit of an overkill. That's ok - if you only need to get application settings, there's a couple of shortcuts you can take!

Remember the good old GetEnvironmentVariable() ? The one we've been using since... Well, I suppose since .NET Framework 1.1!

Guess what? It still works!

So, if the only thing you need the configuration for is application settings, just run this to return value for key "ClientId":

// C# Environment Variables example for Azure Functions v1 or v2 runtime

// This works all the way up to but not including .NET Core 2.0
var clientId = Environment.GetEnvironmentVariable("ClientId");
var clientSecret = Environment.GetEnvironmentVariable("ClientSecret");
var aadDomain = Environment.GetEnvironmentVariable("AADDomain");

Interestingly enough, the GetEnvironmentVariable() doesn't seem to work in .NET Core 2.0 anymore, though.

A quick side note: In case you're not developing an Azure Function (but rather a Web App or something), you could inject the handy IConfiguration (from "Microsoft.Extensions.Configuration") parameter to the Startup method, and you henceforth you can access the application settings like this:

// C# Injected Configuration object example
// This works for .NET Core 1.x and later!

public class Startup
{
 public Startup(IConfiguration configuration)
 {
  Configuration = configuration;
 }

 public IConfiguration Configuration { get; }

 public void ConfigureServices(IServiceCollection services)
 {
  var clientId = Configuration["Values:ClientId"];

  // The rest of the implementation omitted ...
 }
}

... but for an Azure Function, you don't have it available as is. Instead, use the way shown above for v1, v2, or v3.

Where are these configuration keys stored in?

Okay - back to basics for a second. Where do these different methods get their values from? Where do you need to look at, if you're not getting what you're expecting?

For Azure Functions app settings, they're stored either locally in a configuration file, or when deployed, in the Azure (Function) App Service's application settings (Platform Features > Configuration > Application settings).

And an example of a local configuration file ("local.settings.json") containing these values is below:

The contents look something like this:

{
 "IsEncrypted": false,
 "Values": {
  "AzureWebJobsStorage": "",
  "AzureWebJobsDashboard": "",
  "ClientID": "[your value here]", // "Application ID" from Azure AD app registration
  "ClientSecret": "[your value here]",
  "AADDomain": "[your value here]"
 }
}

This example is for Azure Functions v2 or v3.

See more info

Below are a couple of great links for further reading:

• Runtime version differences and such: https://docs.microsoft.com/en-us/azure/azure-functions/functions-versions?tabs=in-process%2Cv4&pivots=programming-language-csharp
• General stuff about ASP.NET "configuration": https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-2.1
• Using the ConfigurationBuilder: https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.configuration.configurationbuilder?view=aspnetcore-2.1
• https://blog.jongallant.com/2018/01/azure-function-config/ <-- This guy's blog is a great resource for all Azure-related stuff, so you should probably bookmark it. I mean, I did.
• Examples for accessing the application settings - there's one for Cosmos DB, if that's your thing! https://vispud.blogspot.com/2019/05/azure-functions-database-connection.html