如何在.NET Azure Http函数中24小时复用实例化对象以提升性能

方案1：使用静态字段实现延迟初始化复用 #

利用Azure函数宿主进程的生命周期，静态成员会在进程存活期间保持实例，结合Lazy<T>实现线程安全的延迟初始化，避免重复实例化。

public static class ReusableServiceHolder
{
    // Lazy<T>保证线程安全的延迟初始化，仅第一次访问时创建实例
    private static readonly Lazy<MyHeavyService> _lazyService = new Lazy<MyHeavyService>(
        () => new MyHeavyService(), 
        LazyThreadSafetyMode.ExecutionAndPublication);
    
    public static MyHeavyService Instance => _lazyService.Value;
}

public class MyHttpFunction
{
    [FunctionName("MyHttpTrigger")]
    public async Task<IActionResult> Run(
        [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
        ILogger log)
    {
        // 直接复用已初始化的实例
        var service = ReusableServiceHolder.Instance;
        // 执行业务逻辑
        return new OkObjectResult("处理完成");
    }
}

方案2：依赖注入配置单例模式 #

通过Azure函数的DI容器注册单例服务，容器会在宿主生命周期内维护唯一实例，无需手动管理静态字段。

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<MyHeavyService>();
        }
    }

    public class MyHeavyService
    {
        // 这里放置耗时的初始化逻辑，比如加载大资源、建立外部连接等
        public MyHeavyService()
        {
            // 初始化操作
        }
    }

    public class MyHttpFunction
    {
        private readonly MyHeavyService _service;

        // 构造函数注入单例服务
        public MyHttpFunction(MyHeavyService service)
        {
            _service = service;
        }

        [FunctionName("MyHttpTrigger")]
        public async Task<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
            ILogger log)
        {
            // 使用复用的实例处理请求
            return new OkObjectResult("处理完成");
        }
    }
}

关键注意事项 #

1. 避免宿主回收：

   • 消耗计划下函数闲置20分钟会被回收，若要保证24小时复用，需切换到高级计划/专用计划，并开启「始终开启」配置；
   • 若无法切换计划，可添加一个每分钟触发的定时函数，向HTTP函数发送空请求，维持宿主活跃。

2. 线程安全处理：
   多个请求会并发访问同一实例，服务类的方法必须保证线程安全——要么设计无状态逻辑，要么用lock、线程安全容器等同步机制保护共享资源。

3. 24小时周期刷新实例：
   若需要实例最多复用24小时后自动刷新，可在服务类内记录初始化时间，每次使用时检查并重新初始化：

   public class MyHeavyService
   {
       private readonly object _lockObj = new object();
       private DateTime _initTime;
   
       public MyHeavyService() => Initialize();
   
       private void Initialize()
       {
           // 重新执行初始化逻辑
           _initTime = DateTime.UtcNow;
       }
   
       public void DoWork()
       {
           lock (_lockObj)
           {
               if (DateTime.UtcNow - _initTime > TimeSpan.FromHours(24))
               {
                   Initialize();
               }
           }
           // 执行业务操作
       }
   }
   

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