Azure Functions Isolated模型：宿主与工作进程依赖库隔离代码示例需求

1. In-Process 模型：宿主与函数共享依赖 #

In-Process模型中，函数直接运行在宿主进程内，依赖通过Startup.cs统一注入，宿主与函数共享同一套依赖容器和库资源。

代码示例：共享依赖的配置与使用 #

// Startup.cs (In-Process 模型)
using Microsoft.Azure.Functions.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection;

[assembly: FunctionsStartup(typeof(MyFunctionApp.Startup))]
namespace MyFunctionApp
{
    public class Startup : FunctionsStartup
    {
        public override void Configure(IFunctionsHostBuilder builder)
        {
            // 注册的服务会同时被宿主进程和函数逻辑复用
            builder.Services.AddSingleton<IMySharedService, MySharedService>();
            // 第三方NuGet包直接安装到项目，宿主和函数均可访问
            builder.Services.AddHttpClient();
        }
    }

    public class SharedHttpFunction
    {
        private readonly IMySharedService _sharedService;

        // 依赖由宿主容器直接注入
        public SharedHttpFunction(IMySharedService sharedService)
        {
            _sharedService = sharedService;
        }

        [FunctionName("SharedHttpTrigger")]
        public IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req)
        {
            var content = _sharedService.GetSharedContent();
            return new OkObjectResult($"Shared service output: {content}");
        }
    }

    public interface IMySharedService
    {
        string GetSharedContent();
    }

    public class MySharedService : IMySharedService
    {
        public string GetSharedContent() => "Content from shared dependency";
    }
}

核心特点 #

• 所有依赖库（包括第三方NuGet包）直接加载进宿主进程，函数无需额外隔离配置
• 依赖容器与宿主完全共享，不存在进程间的资源隔离

2. Isolated 模型：宿主与函数依赖分离 #

Isolated模型中，函数运行在独立的工作进程，宿主与工作进程拥有各自独立的依赖集，函数的依赖需在Program.cs中单独配置。

代码示例：独立依赖的配置与使用 #

// Program.cs (Isolated 模型)
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults()
    .ConfigureServices(services =>
    {
        // 此处注册的服务仅在函数工作进程内生效，宿主进程无法访问
        services.AddSingleton<IMyIsolatedService, MyIsolatedService>();
        services.AddHttpClient();
    })
    .Build();

host.Run();

public class IsolatedHttpFunction
{
    private readonly IMyIsolatedService _isolatedService;

    // 依赖由工作进程的独立容器注入
    public IsolatedHttpFunction(IMyIsolatedService isolatedService)
    {
        _isolatedService = isolatedService;
    }

    [Function("IsolatedHttpTrigger")]
    public HttpResponseData Run(
        [HttpTrigger(AuthorizationLevel.Function, "get")] HttpRequestData req)
    {
        var content = _isolatedService.GetIsolatedContent();
        var response = req.CreateResponse(System.Net.HttpStatusCode.OK);
        response.WriteString($"Isolated service output: {content}");
        return response;
    }
}

public interface IMyIsolatedService
{
    string GetIsolatedContent();
}

public class MyIsolatedService : IMyIsolatedService
{
    public string GetIsolatedContent() => "Content from isolated dependency";
}

核心特点 #

• 函数项目的依赖库仅加载到工作进程，与宿主进程的依赖完全隔离
• 工作进程的依赖配置独立，不受宿主依赖版本或类型的限制

3. 迁移时的关键变化点 #

从In-Process切换到Isolated模型，依赖管理层面需关注：

• 启动配置替换：移除Startup.cs，改用Program.cs通过HostBuilder配置依赖
• 依赖兼容性检查：部分仅支持In-Process的第三方库（如特定绑定扩展）需替换为Isolated兼容版本
• API适配：函数触发器、返回值及依赖注入的API存在差异（如HttpRequest改为HttpRequestData），需同步调整

内容的提问来源于stack exchange，提问作者user27317901