Dependency Injection in Azure Functions with C#

namespace DependencyInjectionFunctions
{
   public class Startup
   {      
   }
}

The next few lines of code added is the most easily forgotten but they are essential to ensuring that your project uses the code in Startup:

using DependencyInjectionFunctions;
using Microsoft.Azure.Functions.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;

[assembly: FunctionsStartup(typeof(Startup))]
namespace DependencyInjectionFunctions
{
   public class Startup : FunctionsStartup
   {
      public override void Configure(IFunctionsHostBuilder builder)
      {
         throw new System.NotImplementedException();
      }
   }
}

Our Startup class needs to implement FunctionsStartup which itself implements IWebJobStartup .

We can now start to register our dependencies to the IoC container, which resolves our dependencies at runtime, like so, where IRepository is an example name of an interface and Repository would be the class that you would like injected that implements the interface:

using DependencyInjectionFunctions;
using Microsoft.Azure.Functions.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;

[assembly: FunctionsStartup(typeof(Startup))]
namespace DependencyInjectionFunctions
{
   public class Startup : FunctionsStartup
   {
      public override void Configure(IFunctionsHostBuilder builder)
      {
         builder.Services.AddSingleton<IRepository, Repository>();
         // or one of the options below
         // builder.Services.AddScoped<IRepository, Repository>();
         // builder.Services.AddTransient<IRepository, Repository>();
         builder.Services.AddLogging();
      }
   }

public interface IRepository
{
    string GetData();
}
public class Repository : IRepository
{
   public string GetData()
   {
       return "some data!";
   }
 }
}

public class HttpTriggerFunction
{
  private readonly IRepository _repository;

  public HttpTriggerFunction(IRepository repository)
  {
      _repository = repository;
  }

  [FunctionName("HttpTrigger")]
  public async Task<IActionResult> Run(
      [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
      ILogger log)
  {
     log.LogInformation("C# HTTP trigger function processed a request.");
     var someData = _repository.GetData();
     return new OkObjectResult(someData);
  }
}

If you've used Azure Functions before, you may remember that classes used to be static classes. This is no longer the case. To enable DI we need to have a constructor, for constructor injection , and a static class cannot have a constructor.

In the code above, you can see that we have added a private, readonly property with the injected interface as its type. Then we have the interface as a parameter in the constructor. The IoC container will inject the correct implementation of the interface based on the setup in the Startup class.

Our class is now ready for us to use with the Function! You can test this using a program such as Postman .

To do this, run the function from the CLI using the func start command.

If you followed the along with the code above it should be http://localhost:7071/api/HttpTrigger . Call this URL from Postman, using a GET or a POST request, and the response will be "some data!".

The ability to use Dependency Injection in Azure Functions means that solutions can be better written using proven design patterns for better maintainability and testability. Enjoy!