Configure lifecycle hooks to implement fine-grained control over key steps in lifecycles of function instances - Function Compute

Function Compute calls lifecycle hooks when specific instance events occur, letting you run setup and teardown code outside your handler. The C# runtime supports two hooks: Initializer and PreStop. For background on instance lifecycle management, see Configure instance lifecycles.

Lifecycle hooks are billed the same way as standard function invocations. Hook execution logs appear in Function Logs, Real-time Logs, and Advanced Logs, but not in the invocation request list.

How Initializer and PreStop work

Initializer

The Initializer hook runs after a function instance starts and before the first handler invocation. Function Compute guarantees it runs exactly once per instance lifetime.

If the Initializer hook fails, the invocation returns an error. On the next invocation, Function Compute creates a new instance and retries the Initializer hook.

Use the Initializer hook for one-time setup — for example, initializing SDK clients or database connections. Because Function Compute reuses warm instances across invocations, setup code in the Initializer hook runs once and its results are available to every subsequent handler call on that instance.

PreStop

The PreStop hook runs before a function instance is destroyed. Use it to flush buffers, close connections, or release resources before the instance shuts down.

Method signature

Both Initializer and PreStop hooks use the same method signature: one IFcContext input parameter and no return value.

Instance method:

public void FunctionName(IFcContext context);

Static method:

public static void FunctionName(IFcContext context);

Example

The following example shows a class that implements both hooks alongside a stream handler.

using System;
using System.IO;
using System.Threading.Tasks;
using Aliyun.Serverless.Core;
using Microsoft.Extensions.Logging;

namespace Example
{
    public class Hello
    {
        public void Initialize(IFcContext context)
        {
            IFcLogger logger = context.Logger;
            logger.LogInformation("Initialize start");
            logger.LogInformation("Handle initializer: {0}", context.RequestId);
            logger.LogInformation("Initialize end");
        }

        public void PreStop(IFcContext context)
        {
            IFcLogger logger = context.Logger;
            logger.LogInformation("PreStop start");
            logger.LogInformation("Handle PreStop: {0}", context.RequestId);
            logger.LogInformation("PreStop end");
        }

        public async Task<Stream> StreamHandler(Stream input, IFcContext context)
        {
            IFcLogger logger = context.Logger;
            logger.LogInformation("Handle request: {0}", context.RequestId);

            MemoryStream copy = new MemoryStream();
            await input.CopyToAsync(copy);
            copy.Seek(0, SeekOrigin.Begin);
            return copy;
        }

        static void Main(string[] args){}
    }
}