CODEWITHSUNDEEP
c#.netasynchronouscallback
Mike Baxter
Mike Baxter

Reputation: 7268

Wrapping a callback-based class to an async one

I'm referencing a class that performs various demanding operations using callbacks rather than async operations. For example:

class CallbackClass : SomeSdkCallbacks
{
    public void RequestData()
    {
        // We call this to request some data.
        // After some time, this will trigger OnDataReturned to be called
    }

    public void OnDataReturned(DataObject data)
    {
        // This will be called automatically with returned data via SomeSdkCallbacks
    }
}

There are many instances of this type of structure throughout this class.

What I'm trying to do is create a wrapper class around this one that simplifies it's usage. The structure that I'm going for at the moment is:

class MyWrapperClass
{
    CallbackClass CallbackClass;

    public MyWrapperClass()
    {
        this.CallbackClass = new CallbackClass();
    }

    public DataObject GetData()
    {
        this.CallbackClass.RequestData();

        // Somehow wait until this.CallbackClass.OnDataReturned is called?

        // Somehow get the data that would be passed in to this.CallbackClass.OnDataReturned()???
    }
}

What is the best method of wrapping up a 'callback' architecture into a single asynchronous method?

Edit: To clarify, ideally I would like to package this up into a single method that can return the data in a single request. See the MyWrapperClass.GetData() method in my example for my ideal structure.

Edit 2: I'm aware that this desired architecture is bad form. Unfortunately that is the requested structure that has been asked of me.

Upvotes: 3

Views: 811

Answers (2)

Filip Cordas
Filip Cordas

Reputation: 2561

I think this is what you want:

        class CallbackClass<T>
        {
            private TaskCompletionSource<T> task = new TaskCompletionSource<T>();

            public void RequestData()
            {
               
            }

            public void OnDataReturned(T data)
            {
                task.SetResult(data);
            }

            public Task<T> Task { get { return task.Task; } }
        }

        class MyWrapperClass
        {
            public Task<DataObject> GetData()
            {
                var cls = new CallbackClass<DataObject>();

                cls.RequestData();

                return cls.Task;
            }
        }

Just note that TaskCompletionSource must be created per operation so you don't use the same one for two different calls. With this you can use the async keyword. This might help a bit more.

Upvotes: 2

Andrei S.
Andrei S.

Reputation: 119

In your situation you can add some event on CallBackClass. Like here:

class CallbackClass : SomeSdkCallbacks
{
    public event Action<object> DataReturnedEvent;
    public void RequestData()
    {
        // We call this to request some data.
        // After some time, this will trigger OnDataReturned to be called
    }
    public void OnDataReturned(DataObject data)
    {
        DataReturnedEvent?.Invoke(data);
    }
}

And you can use the event in the wrapper class

class MyWrapperClass
{
    CallbackClass CallbackClass;

    public MyWrapperClass()
    {
        this.CallbackClass = new CallbackClass();
        CallbackClass.DataReturnedEvent =+ ProcessData;
    }
    private void ProcessData(object Data)
    {
        //some data processing
    }
    public DataObject GetData()
    {
        this.CallbackClass.RequestData()               
    }
}

Upvotes: 0

Related Questions