在Dynamics CRM插件中：如何强制代码不等待异步响应

Question

So here is my scenario. I have to call an Azure Function through Dynamics CRM plugin code (C#) asynchronously, that is fine. But I don't want the code to wait for Azure Function's response . I just want to complete the code execution and exit.

The Azure Function will take care of the updates back in the CRM if necessary.

The reason why I don't want to wait is there is a 2 minutes time limit for plugin execution to complete in CRM Online. However, Azure Function could take several minutes to complete the process.

Here is my plugin class code that is making a synchronous call to Azure Function. (I can convert the call to async following this document, but following that approach my code will still be waiting for the response).

public class CallAzureFunc : IPlugin
{
    public void Execute(IServiceProvider serviceProvider)
    {
        // Extract the tracing service for use in debugging sandboxed plug-ins.  
        ITracingService tracer = (ITracingService)serviceProvider.GetService(typeof(ITracingService));

        // Obtain the execution context from the service provider.  
        IPluginExecutionContext context = (IPluginExecutionContext) serviceProvider.GetService(typeof(IPluginExecutionContext));

        // The InputParameters collection contains all the data passed in the message request.  
        if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)
        {
            // Obtain the target entity from the input parameters.  
            Entity entity = (Entity)context.InputParameters["Target"];

            // Verify that the target entity represents an entity type you are expecting.   
            if (entity.LogicalName != "account")
                return;

            // Obtain the organization service reference which you will need web service calls.  
            IOrganizationServiceFactory serviceFactory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
            IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);

            try
            {
                // Plug-in business logic goes here.  

                Data data = new Data
                {
                    name = entity.Attributes["name"].ToString()
                };

                string result = CallFunction(tracer, data);
                tracer.Trace($@"result: {result}");
            }

            catch (FaultException<OrganizationServiceFault> ex)
            {
                throw new InvalidPluginExecutionException("An error occurred in MyPlug-in.", ex);
            }

            catch (Exception ex)
            {
                tracer.Trace("MyPlugin: {0}", ex.ToString());
                throw;
            }
        }
    }

    private string CallFunction(ITracingService tracer, Data data)
    {
        string json = JsonConvert.SerializeObject(data);

        string apiUrl = "https://<AzureFunctionName>.azurewebsites.net/api/";
        string token = "<token>";
        string content = null;
        string apiMethod = "CreateContactFromLead";
        string inputJson = json;
        string result = ApiHelper.ExecuteApiRequest(apiUrl, token, content, apiMethod, inputJson, tracer);
        return result;
    }
}

And here are the helper methods to make an API call.

    internal static string ExecuteApiRequest(string apiUrl, string token, string content, string apiMethod, string inputJson, ITracingService tracer)
    {
        try
        {
            var data = Encoding.ASCII.GetBytes(inputJson);

            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(String.Format(apiUrl + apiMethod));
            request.Method = "POST";
            request.ContentLength = inputJson.Length;
            request.ContentType = "application/json";
            request.ContentLength = data.Length;
            request.Headers.Add("x-functions-key", token);
            request.Accept = "application/json";

            // Send the data
            Stream newStream = request.GetRequestStream();
            newStream.Write(data, 0, data.Length);
            newStream.Close();

            // Get the resposne
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();

            if (response != null)
            {
                tracer.Trace("ApiHelper > ExecuteApiRequest > response.StatusCode: " + response.StatusCode);
                tracer.Trace("ApiHelper > ExecuteApiRequest > response.StatusDescription: " + response.StatusDescription);
            }

            if (response.StatusCode == HttpStatusCode.OK || response.StatusDescription == "OK" || response.StatusDescription == "200")
            {
                content = ReadStream(response, tracer);
            }
            else if (response.StatusCode == HttpStatusCode.NoContent || response.StatusDescription == "No Content" || response.StatusDescription == "204")
            {
                content = null;
            }
            else
            {
                if (response != null)
                {
                    throw new Exception(String.Format("Status Code: {0}, Status Description: {1}",
                        response.StatusCode,
                        response.StatusDescription));
                }
            }

            return content;
        }
        catch (Exception ex)
        {
            tracer.Trace("ApiHelper > ExecuteApiRequest > error: " + ex.Message);
            throw;
        }
    }

    private static string ReadStream(HttpWebResponse response, ITracingService tracer)
    {
        try
        {
            var responseJson = string.Empty;
            if (response != null)
            {
                Stream dataStream = response.GetResponseStream();
                if (dataStream != null)
                {
                    using (StreamReader reader = new StreamReader(dataStream))
                    {
                        while (!reader.EndOfStream)
                        {
                            responseJson = reader.ReadToEnd();
                        }
                    }
                }
            }
            return responseJson;
        }
        catch (Exception ex)
        {
            tracer.Trace("ApiHelper > ReadStream > error: " + ex.Message);
            throw ex;
        }
    }

Answer 1

You need two functions.

Function #1 will be called by your plugin (essentially what you are doing now.) It will validate the inputs. If the inputs are successful it will place a message (presumably that includes the relative data from the caller) in an Azure Service Bus Queue . After placing a message on the service bus queue it will terminate and return a success message to the caller (ie, the plugin code.)

Function # 2 will be triggered by an Azure Service Bus Queue message. This function will handle the long-running code based on the message content (from Function # 1.)

Example of Azure Service triggered Azure Function :

[FunctionName("ServiceBusQueueTriggerCSharp")]                    
public static void Run(
    [ServiceBusTrigger("myqueue", AccessRights.Manage, Connection = "ServiceBusConnection")] 
    string myQueueItem,
    Int32 deliveryCount,
    DateTime enqueuedTimeUtc,
    string messageId,
    TraceWriter log)
{
    log.Info($"C# ServiceBus queue trigger function processed message: {myQueueItem}");
    log.Info($"EnqueuedTimeUtc={enqueuedTimeUtc}");
    log.Info($"DeliveryCount={deliveryCount}");
    log.Info($"MessageId={messageId}");
}

This pattern is commonly used because it provides transaction execution safety. If you only had the one function, as described above, and the Function failed the call would be lost since there was no listener for completion.

Using two functions we have safety. If Function # 1 fails (either validation or placing a message on the queue) it will fail to the caller, and your plugin code can handle as appropriate. If Function # 2 fails it will fail back to the Service Bus and be queued for retry (by default it is retried up to 5 times and then written to a poison queue.)