Callback in c#

Download

Running tasks in background is the need of the hour when working on real world applications. There are few tasks which we can fire and forget but for few of them we will like to receive the feedback. This is when callbacks comes into the picture and provides a channel for these objects to communicate with each other.

These tasks are very common in desktop and mobile applications. In this post we will talk about callback mechanism in c#. In future post we will build upon this and do lot more.

Using interfaces for callbacks in c#

using System;
using System.Threading;

namespace Callbacks
{
    
    class Program
    {
        static void Main(string[] args)
        {
            var consumer = new Consumer();
            consumer.DoWork();
            Console.ReadLine();
        }
    }

    interface IOnProcessCompleteListener
    {
        void OnProcessComplete(string message);
    }

    internal class Consumer: IOnProcessCompleteListener
    {
        private Worker _worker;
        public Consumer()
        {
            _worker = new Worker();
            _worker.OnProcessCompleteListener = this;
        }

        public void DoWork()
        {
            Thread backgroundThread = new Thread(_worker.DoBackgroundWork);
            backgroundThread.Start();
            Console.WriteLine("Control is with main thread");
        }

        public void OnProcessComplete(string message)
        {
            Console.WriteLine(message);
        }
    }
    internal class Worker
    {
        public IOnProcessCompleteListener OnProcessCompleteListener;

        public void DoBackgroundWork()
        {
            Console.WriteLine("In worker");
            Thread.Sleep(1000);

            if(OnProcessCompleteListener != null)
                OnProcessCompleteListener.OnProcessComplete("Consumer has been called back");
        }

    }
}

Code is self explanatory and thus I will provide just a brief on it. We created an interface IOnProcessCompleteListener it has just one method. In the Worker class we have an data member which accepts an object of class which implements IOnProcessCompleteListener. This ensures that we can call OnProcessComplete method on this member once we are ready to call it back. The Consumer class will implement IOnPropertyChangeListener. Once Worker is done with stuff it will notify Consumer using the callback object. Just to simulate some background process I have made the worker thread to sleep before giving the call back.

Using Delegates to callback in c#

using System;
using System.Threading;

namespace CallBacksUsingDelegate
{
    class Program
    {
        static void Main(string[] args)
        {

            Listener listener = new Listener();
            listener.DoWork();
            Console.WriteLine("Now in main thread");
            Console.ReadLine();
        }
    }

    internal delegate void OnProcessComplete(string message);

    internal class Worker
    {
        public OnProcessComplete ProcessComplete;

        public void Process()
        {
            Console.WriteLine("Process: Running on " + Thread.CurrentThread.Name);
            Thread.Sleep(1000);
            if (ProcessComplete != null)
                ProcessComplete.Invoke("Process has completed");
        }
    }

    internal class Listener
    {
        private Worker _worker;
        public Listener()
        {
            _worker = new Worker();
            _worker.ProcessComplete = this.ProcessCompleteListener;
        }

        public void DoWork()
        {
            Thread backgroundThread = new Thread(_worker.Process);
            backgroundThread.Name = "Background Thread";
            backgroundThread.Start();
        }

        private void ProcessCompleteListener(string message)
        {
            Console.WriteLine(message);
        }
    }

}

In this case we have a delegate - OnProcessComplete. Class worker has an object of type OnProcessComplete and class Listener passes the callback function to the Worker wrapped in this delegate. Once the Worker is done with its stuff it invokes the delegate and passes the control back.

In the coming posts we will explore this power a bit more and try to do something more meaningful.

Your inputs are really important for me so please do provide them. Share it if you care :)