Use independent injected services in durable activity function

[paulprivalgo]

Hello

I originally asked this on StackOverflow then came across here so I have asked here as well in the hope I can get some help with a major issue I have with Activity functions

I have a orchestrator function

This takes data which is split by client

    [FunctionName(nameof(ProcessDataWithDurableFunctions))]
     public  async Task<List<string>> RunOrchestrator([OrchestrationTrigger] 
         IDurableOrchestrationContext context)
     {
         
    	 dataSplitByClient = JsonConvert.DeserializeObject<Dictionary<string, ProcessClientData>>(json);
     
         var tasks = new List<Task<string>>();
         foreach (var item in dataSplitByClient)
         {
             tasks.Add(ProcessClientWithContextAsync(context, item.Value));
         }
    
         await Task.WhenAll(tasks);
         
         var outputs = tasks.Select(x => x.Result).ToList();
         return outputs;
     }

     private Task<string> ProcessClientWithContextAsync(IDurableOrchestrationContext context, ProcessClientData item)
        {
            context.SetCustomStatus(new
            {
                item.ClientName,
                item.ClientId, 
                TotalItemsToProcess = item.Data.Count
            });

            _tmService.Identifier = item.ClientName;

            var result = context.CallActivityAsync<string>(nameof(ProcessClientData), item);
            return result;
        }

I want to process data for each client using an activity function ProcessClientData

       [FunctionName(nameof(ProcessClientData))]
       public async Task<string> ProcessClientData([ActivityTrigger] ProcessClientData clientToProcessDataFor, 
           ILogger logger)
       {
           var stringBuilder = new StringBuilder();
           var logText = $"Processing Data for {clientToProcessDataFor.ClientName} with {clientToProcessDataFor.Data.Count} events";
           stringBuilder.AppendLine(logText);
           logger.LogInformation(logText);

           logger.LogInformation(_myService.Identifier);

           logText = $"Finished Processing Data for {clientToProcessDataFor.ClientName} with {clientToProcessDataFor.Data.Count} events";
           stringBuilder.AppendLine(logText);
           logger.LogInformation(logText);

           var result = stringBuilder.ToString().RemoveTrailingCrlf();
           return result;
       }

This is where I hit a big issue.

I need each activity function instance to have its own instance of DataProcessorService which is a transient service containing an efcore DbContext

This whole architecture wont work in its current form because it is never possible to run operations in parallel within a DbContext

I would be running activity functions in parallel so I will get concurrent issues

Ideally I would be able to inject IDataProcessorService into the activity function but annoyingly this is not supported

How can I get round this major issue?

Paul

[buckprime]

You can use dependency injection, see here: Use dependency injection in .NET Azure Functions
Although that's about plain Azure Functions, it will work with durable functions.

And if you're using isolated mode, dependency injection is supported by default.

[paulprivalgo]

This doesnt answer my specific issue though. I need each instance of an activity function to have its own version of the injected services. The standard approach does not support this - It shares a service with all the activity functions. This prevents me from using Durable functions because my services use EF core and EF DbContexts are not thread safe and will not support any operations being run concurrently

[buckprime]

You mean because all the activity functions are in the same class? You can put them in separate classes. And although this is not clearly documented, each invocation of an activity function will create a new instance of the class and call the activity function on it, so a transient service that is injected will have a lifetime that is just for that invocation of the function.

[paulprivalgo]

ok that sounds interesting!

Are there any samples around for doing that? Im only aware of how to call activity functions in the same class

Paul

[buckprime]

I don't know if there are any samples, but you don't need to do anything other than put them in separate classes and it will just work. For instance, you could take the example code that gets generated when you create a durable functions project in Visual Studio and move the functions into separate non-static classes, like this:

    public class RunOrchestratorClass
    {
        [FunctionName("Function1")]
        public static async Task<List<string>> RunOrchestrator(
            [OrchestrationTrigger] IDurableOrchestrationContext context)
        {
            var outputs = new List<string>();

            // Replace "hello" with the name of your Durable Activity Function.
            outputs.Add(await context.CallActivityAsync<string>(nameof(SayHelloClass.SayHello), "Tokyo"));
            outputs.Add(await context.CallActivityAsync<string>(nameof(SayHelloClass.SayHello), "Seattle"));
            outputs.Add(await context.CallActivityAsync<string>(nameof(SayHelloClass.SayHello), "London"));

            // returns ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
            return outputs;
        }
    }

    public class SayHelloClass
    {
        [FunctionName(nameof(SayHello))]
        public static string SayHello([ActivityTrigger] string name, ILogger log)
        {
            log.LogInformation("Saying hello to {name}.", name);
            return $"Hello {name}!";
        }
    }

    public class HttpStartClass
    {
        [FunctionName("Function1_HttpStart")]
        public static async Task<HttpResponseMessage> HttpStart(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestMessage req,
            [DurableClient] IDurableOrchestrationClient starter,
            ILogger log)
        {
            // Function input comes from the request content.
            string instanceId = await starter.StartNewAsync("Function1", null);

            log.LogInformation("Started orchestration with ID = '{instanceId}'.", instanceId);

            return starter.CreateCheckStatusResponse(req, instanceId);
        }
    }

Each of these classes could then have its own constructor with its own parameters that get injected.

[paulprivalgo]

ok thanks! Is there a reason why the activity functions are static? Is this mandotory?