正确使用 Azure Durable Function - 序列化复杂对象答案

【问题标题】：Correct use of Azure Durable Function - Serializing Complex Objects正确使用 Azure Durable Function - 序列化复杂对象
【发布时间】：2018-10-10 10:36:47
【问题描述】：

所以我正在制作一些 Azure 持久功能的原型，以尝试了解它们是否适合我们内部 API 系统的建议解决方案。

基于示例，我创建了一个Orchestrator 客户端 (HelloOrchestratorClient.cs)，它响应HttpTrigger。该客户端从原始请求中提取一些信息，然后继续触发 Orchestrator Function (HelloOrchestrator.cs) 传递一些提取的信息：

复杂的 HelloOrchestratorClient.cs：

[FunctionName("HttpSyncStart")]
public static async Task<HttpResponseMessage> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, methods: "get", Route = "orchestrators/{functionName}/wait")]
    HttpRequestMessage req,
    [OrchestrationClient] DurableOrchestrationClient starter,
    string functionName,
    ILogger log)
{       
    HttpReq originalRequest = new HttpReq() {
            DeveloperId = GetDevKey(req,apiHeaderKey),
            QueryString = req.RequestUri.Query,
            APIName = GetQueryStringValue(req,APIName),
            APIVersion = GetQueryStringValue(req,APIVersion)

    };
    string instanceId =   await starter.StartNewAsync(functionName, originalRequest);

    TimeSpan timeout = GetTimeSpan(req, Timeout) ?? TimeSpan.FromSeconds(30);
    TimeSpan retryInterval = GetTimeSpan(req, RetryInterval) ?? TimeSpan.FromSeconds(1);

    return  await starter.WaitForCompletionOrCreateCheckStatusResponseAsync(
        req,
        instanceId,
        timeout,
        retryInterval);

}

HelloOrchestrator.cs 现在只是调用我们的一个内部 API 并返回一个 JsonProduct 有效负载（简单的 POCO 描述，你猜对了，一个标题），使用名为 HelloOrchestrator.APICall 的 ActivityTigger 到自己调用 API。

复杂的 HelloOrchestrator.cs：

  [FunctionName("E1_JsonProduct")]
        public static async Task<List<JsonProduct>> Run(
            [OrchestrationTrigger] DurableOrchestrationContextBase context,
            ILogger log)
        {
            List<JsonProduct> output = new List<JsonProduct>();
            HttpReq r = context.GetInput<HttpReq>();
            if(r != null)
            {
                if(r.DeveloperId == null)
                {
                    return output;
                }
                output.Add(await context.CallActivityAsync<JsonProduct>("E1_CallAPI",r));
                return output;
            }
            return output;
        } 

[FunctionName("E1_CallAPI")]
public async static Task<JsonProduct> APICall([ActivityTrigger] HttpReq req,
    ILogger log)
{

    JsonProduct products  = null;
    string u = $"{baseAddress}{req.APIVersion}/{req.APIName}{req.QueryString}";  

    var request = new HttpRequestMessage(HttpMethod.Get, u);
    request.Headers.Accept.Add(
        new MediaTypeWithQualityHeaderValue("application/json")
    );
    request.Headers.Add("x-apikey",req.DeveloperId);
     log.LogInformation($"URL calling = '{request.RequestUri.AbsoluteUri}'.");
    HttpResponseMessage response = await client.SendAsync(request);
    // return await response.Content.ReadAsStringAsync();
    if(response.IsSuccessStatusCode)
    {
        var formatter = new JsonMediaTypeFormatter
        {
            SerializerSettings = HelloProj.CosmosDB.Models.Products.Converter.Settings
        };

        products = await response.Content.ReadAsAsync<JsonProduct>(new [] {formatter});
    }
    return products;
}

旁注： 计划是，如果我可以让它工作，就是将一堆进程扇出到不同的 API 并再次扇入并合并 JSON 有效负载并将其返回给始作俑者。

我遇到的问题

所以，当我的 List<JsonProduct> 从 HelloOrchestrator.Run 返回时，我会收到在此 Gist（大堆栈跟踪）上找到的以下 NullReferenceException，并收到来自的 500 响应 Orchestrator 客户端。

以下证明返回的output在运行时确实有一个对象：

可能是因为JsonProduct的复杂性（再次找到模型类here）？我问，因为当我将我的 Orchestrator Function 换成更简单的模型结构时，我没有收到 500，我收到我的 JSON有效载荷。

此示例显示Simple Orchestrator 函数HelloOrchestrator.cs，返回一个简单的TestToDo.cs (Gist for model) 平面对象，不会出错：

简单的 HelloOrchestrator.cs：

   [FunctionName("E1_Todo")]
    public static async Task<TestToDo> RunToDo(
    [OrchestrationTrigger] DurableOrchestrationContextBase context,
        ILogger log)
    {
        HttpReq r = context.GetInput<HttpReq>();
        TestToDo todo = new TestToDo();
        if(r != null)
        {
            todo = await context.CallActivityAsync<TestToDo>("E1_CallAPITodo",r);
        }
        return todo;
    }

[FunctionName("E1_CallAPITodo")]
public async static Task<TestToDo> APITodoCall([ActivityTrigger] HttpReq req,
    ILogger log)
{

    var request = new HttpRequestMessage(HttpMethod.Get, "https://jsonplaceholder.typicode.com/todos/1");
    request.Headers.Accept.Add(
        new MediaTypeWithQualityHeaderValue("application/json")
    );
     log.LogInformation($"URL calling = '{request.RequestUri.AbsoluteUri}'. for {req.QueryString}");
    HttpResponseMessage response = await client.SendAsync(request);
    return await response.Content.ReadAsAsync<TestToDo>();
}

复杂的 HelloOrchestratorClient.cs：

复杂的 HelloOrchestrator.cs：

我遇到的问题

简单的 HelloOrchestrator.cs：

更多信息