API methods do not return when exceptions are thrown

[iant-ee]

I have the following code:

try {
    ApiResponse response = gateway.TransactionInquiry(ipgTransactionId);
    var success = true;
}
catch (ApiException ex)
{
    var success = false;
}

I'm currently waiting for my apiKey and secret, so these variables are set to junk. If I attach debugging tools then I can see that this code triggers the expected TransactionInquiry call, and the API returns a 401 response. So far so good. However, if I step through the code, no lines are called after I step past the TransactionInquiry line. I would expect an ApiException to be thrown and success to be set to false.

To track down the problem, I unwrapped TransactionInquiry using this code:

var apiSecret = "def";
var credentials = new MerchantCredentials(apiKey, apiSecret);
var clientContext = new ClientContext(credentials);
var signatureService = new Signature(apiKey, apiSecret);
var payApi = new PaymentApi(clientContext.Config);
try
{
    var apiResponse = payApi.TransactionInquiryWithHttpInfo(
        "application/json",
        signatureService.ClientRequestId,
        apiKey,
        signatureService.TimeStamp,
        ipgTransactionId,
        signatureService.Sign(),
        null,
        null
    );
    var success = true;
}
catch (Exception e)
{
    var success = false;
}

This has the same problem. However, if I change the line apiResponse line to use Async:

var apiResponse = payApi.TransactionInquiryWithHttpInfo(...)

Then it will throw the expected ApiException.

Reviewing the code in https://github.com/GBSEcom/DotNet/blob/master/src/Org.OpenAPITools/Client/ApiClient.cs I can see the Get method is:

{
    return GetAsync(path, options).Result;
}

I believe this is hitting the deadlock problem described at https://docs.microsoft.com/en-us/archive/msdn-magazine/2015/july/async-programming-brownfield-async-development (see the section starting "The Blocking Hack").

To get that method working properly I think you'll need to implement one of the solutions described in the article. However, I'm calling your API from a method that supports async code, so a much better solution for me would be if you could provide a version of Gateway.cs that included Async method calls.

Something like:

        {
            Signature signatureService = GetSignatureService();
            string messageSignature = signatureService.Sign();
            return await payApi.TransactionInquiryAsync(
                CONTENT_TYPE,
                signatureService.ClientRequestId,
                GetApiKey(),
                signatureService.TimeStamp,
                transactionId,
                messageSignature,
                region,
                storeId
            );
        }

[iant-ee]

The response types seem to be different for the Async methods for some reason.

This version works, although you may want to modify payApi.TransactionInquiryAsyncWithHttpInfo so it returns the same time as the non-async version (wrapped in a task):

        public async Task<ApiResponse<TransactionResponse>> TransactionInquiryAsync(string transactionId, string storeId = null, string region = null)
        {
            Signature signatureService = GetSignatureService();
            string messageSignature = signatureService.Sign();
            return await payApi.TransactionInquiryAsyncWithHttpInfo(
                CONTENT_TYPE,
                signatureService.ClientRequestId,
                GetApiKey(),
                signatureService.TimeStamp,
                transactionId,
                messageSignature,
                region,
                storeId
            );
        }

[ericmargules]

@iant-ee would you find the call either async or sync methods useful or do you consistently just use async? We've gotten a lot of feedback that the async methods should be exposed (as the gateway file currently only targets the synchronous methods).

[iant-ee]

We only need the async methods. That applies to anyone who is calling the API from their own async method.

Some applications will want to call the API from a sync method and there isn't a good way of calling an async method from a sync method in .Net. Your code uses GetAsync(path, options).Result which is causing the deadlock when we try and call your API.

As you are relying on an async method, you must either be an async method yourself, or you must choose a hack to wrap the async call. As a library author, you can't know which hack is appropriate for your users. Therefore I suggest only providing the async method, and passing the decision of which hack to use onto your users.

[ericmargules]

Thanks for your input, @iant-ee. I see the wisdom in what you're suggesting. We're preparing another release for this library so I will try to get these concerns addressed. Timeline is first week of September for the next release.