Announcing General Availability: Azure Logic Apps Standard Custom Code with .NET 8

Microsoft

Jun 10, 2025

We’re excited to announce the General Availability (GA) of Custom Code support in Azure Logic Apps Standard with .NET 8. This release marks a significant step forward in enabling developers to build more powerful, flexible, and maintainable integration workflows using familiar .NET tools and practices.

With this capability, developers can now embed custom .NET 8 code directly within their Logic Apps Standard workflows. This unlocks advanced logic scenarios, promotes code reuse, and allows seamless integration with existing .NET libraries and services—making it easier than ever to build enterprise-grade solutions on Azure.

What’s New in GA

This GA release introduces several key enhancements that improve the development experience and expand the capabilities of custom code in Logic Apps:

Bring Your Own Packages

Developers can now include and manage their own NuGet packages within custom code projects without having to resolve conflicts with the dependencies used by the language worker host. The update includes the ability to load the assembly dependencies of the custom code project into a separate Assembly context allowing you to bring any NET8 compatible dependent assembly versions that your project need. There are only three exceptions to this rule:

Microsoft.Extensions.Logging.Abstractions
Microsoft.Extensions.DependencyInjection.Abstractions
Microsoft.Azure.Functions.Extensions.Workflows.Abstractions

Dependency Injection Native Support

Custom code now supports native Dependency Injection (DI), enabling better separation of concerns and more testable, maintainable code. This aligns with modern .NET development patterns and simplifies service management within your custom logic.

To enable Dependency Injection, developers will need to provide a StartupConfiguration class, defining the list of dependencies:

public class StartupConfiguration : IConfigureStartup
{
    /// <summary>
    /// Configures services for the Azure Functions application.
    /// </summary>
    /// <param name="services">The service collection to configure.</param>
    public void Configure(IServiceCollection services)
    {
        // Register the routing service with dependency injection
        services.AddSingleton<IRoutingService, OrderRoutingService>();
        services.AddSingleton<IDiscountService, DiscountService>();
    }
}

You will also need to initialize those register those services during your custom code class constructor:

public class MySampleFunction
{
    private readonly ILogger<MySampleFunction> logger;
    private readonly IRoutingService routingService;
    private readonly IDiscountService discountService;

    public MySampleFunction(ILoggerFactory loggerFactory, IRoutingService routingService, IDiscountService discountService)
    {
        this.logger = loggerFactory.CreateLogger<MySampleFunction>();
        this.routingService = routingService;
        this.discountService = discountService;
    }

// your function logic here

}

Improved Authoring Experience

The development experience has been significantly enhanced with improved tooling and templates. Whether you're using Visual Studio or Visual Studio Code, you’ll benefit from streamlined scaffolding, local debugging, and deployment workflows that make building and managing custom code faster and more intuitive. The following user experience improvements were added:

Local functions metadata are kept between VS Code sessions, so you don't receive validation errors when editing workflows that depend on the local functions. Projects are also built when designer starts, so you don't have to manually update references.
New context menu gestures, allowing you to create new local functions or build your functions project directly from the explorer area
Unified debugging experience, making it easer for you to debug. We have now a single task for debugging custom code and logic apps, which makes starting a new debug session as easy as pressing F5.