处理必须填充另一个类的实例中的字段的回调

Question

I have a class SomeAction which implements ISomeAction (given to me), it has an async method that calls a non async void method which belongs to a class instance that is provided by a third party sdk. To handle the void in my async method, I use TaskCompletionSource which I intend on setting once I get the response from the third party. The problem is, the response from the service is in the form of a callback which uses a class ThirdPartyCallbackClass that the third party has a defined interface for.

So how can I take the string passed back to the ThirdPartyCallbackClass and use it to update the TaskCompletionSource instance in SomeAction

Here is the code (forgive any typos):

public class SomeAction : ISomeAction
{
    private TaskCompletionSource<string> fbtcs;

    public async Task<string> someTask()
    {
        var accessToken = await SomeAsyncMethod();
        return accessToken;
    }

    private async Task<string> SomeAsyncMethod()
    {
        fbtcs = new TaskCompletionSource<string>();
        TaskClass tc = new TaskClass();
        tc.CallThirdParty();

        return await fbtcs.Task;
    }
}

public class TaskClass
{
    public void CallThirdParty()
    {
        ThirdParty tp = new ThirdParty();
        var somePayload = "payload";
        ThirdPartyCallbackClass callback = new ThirdPartyCallbackClass();
        tp.VoidMethodWithCallback(somePayload, callback);
    }
}

public class ThirdPartyCallbackClass : IThirdPartyDefinedCallback
{
    public void OnSuccess(string p)
    {
        //At this point I want to take p and use it to update SomeAction's fbtcs instance string. Is my design wrong or is there a strategy for dealing with this?
       //If this was in my `SomeAction` instance I would try to do something like...

       //fbtcs.TrySetResult(p);
    }
}

Answer 1

If ThirdParty::VoidMethodWithCallback is a synchronous method then you don't need to use TaskCompletionSource at all, you can call synchronous methods directly in an async or Task<TResult> -returning method:

public class SomeAction : ISomeAction
{
    public Task<String> SomeTaskAsync()
    {
        return Task.FromResult( this.SomeMethod() );
    }

    private String SomeMethod()
    {
        String value = new TaskClass().CallThirdParty();
        return value;
    }
}

public class TaskClass
{
    private class CallbackContainer : IThirdPartyDefinedCallback
    {
        public String ReturnedValue;

        public void OnSuccess(String p)
        {
            this.ReturnedValue = p;
        }
    }

    public String CallThirdParty()
    {
        ThirdParty tp = new ThirdParty();
        var somePayload = "payload";

        CallbackContainer callbackContainer = new CallbackContainer();

        tp.VoidMethodWithCallback( somePayload, callbackContainer );

        return callbackContainer.ReturnedValue;
    }
}

In the event that SomeTaskAsync is called directly from a UI thread or some other thread that should not block, then use Task.Run to run the synchronous method on a Thread-pool thread:

public class SomeAction : ISomeAction
{
    public Task<String> SomeTaskAsync()
    {
        return Task.Run( (Func<String>)this.SomeMethod );
    }
}

Note the standard (ie Microsoft) naming convention in .NET is to always have Async at the end of the name of any method which ultimately executes asynchronously (it doesn't necessarily need to be flagged with the async modifier: it could pass-through a Task<T> from another call, for example).