具有不同数量参数的代表

Question

I have written a DLL which calls off to a third-party API which I do not have access to.

Because of how the user could quit and restart the application every method has lots of logic around the checking of Access and Refresh tokens in order to authenticate with the API. (As well error handling processing) This has resulted in lots of duplicated code for each different API call.

I want to refactor this so I can just pass the type of response object I want to a generic method called ExecuteApiCall. Which can then call an appropriate method for just the specific REST call.

I have created this method with the following signature:

private T ExecuteApiCall<T>(string name, Action<T> requestCall) where T : IApiResponse, new()

and this works as I would expect it. The problem I have now is that a few of the requests require extra parameters and I can't pass a varying number of parameters to an Action delegate.

How do I go about handling this?

I was thinking of changing to

Action<T, ApiRequestParameters>

where ApiRequestParameters is a class of all possible parameters and the public facing method can set what it needs to before calling the private ExecuteApiCall. But this doesn't really feel like best practice.

I really hope this makes sense to someone and thanks in advance. Happy to provide further code examples if required.

The following needs to be handled

ExecuteCallA()
{
    //The API call is done here using RestSharp
}

ExecuteCallB(string aParameter)
{
    //The API call is done here using RestSharp
}

ExecuteCallC(string aParameters, int anotherParameter)
{
    //The API call is done here using RestSharp
}

Or would it be easier to just set the Action to look something like this.

Action<T, object, object, object>

So that it can handle extra parameters and just ignore any it does not need.

EDIT:

Thanks to Sean for the suggestion, this is likely what I will go with. My other option, again not sure on the best practices here...

Would be to have the public signature contain the method parameters and set these to a private field.

private string myParameter;
public ApiResponseA GetWhatever(string a)
{
    myParameter = a;
    ExecuteApiCall<ApiResponseA>();
    myParameter = null;
}

Then change the private method responsible for the actual API call to use the private field instead of a parameter. Thoughts?

Answer 1

I'd add overloads for a certain number of parameters. For example:

private T ExecuteApiCall<T>(string name, Action<T> requestCall) where T : IApiResponse, new();

private T ExecuteApiCall<P1, T>(string name, P1 p1, Action<P1, T> requestCall) where T : IApiResponse, new()

private T ExecuteApiCall<P1, P2, T>(string name, P1 p1, P2 p2, Action<P1, P2, T> requestCall) where T : IApiResponse, new()

// etc

It's a bit repetitive to implement, but once you've done it you can forget about it, and it'll make the API you expose to users a lot cleaner and predictable.