Hooks Method in C#

In this blog, I would explains about “Hooks” and why are they needed.

In my last blog, I explained about Template Method Design Pattern.

In this blog, I would take Template Method to the next level. In this blog, I would explains about “Hooks” and why are they needed.

What are Hooks?

A hook is a method that is declared in the abstract class but it is either empty or contains default implementation.

Why are they needed?

Hooks give subclass the ability to hook into the algorithm (template method) at various points. Subclasses, if they wish, can hook into the algorithm or are free to ignore the hook.

That means there is no obligation that each subclass should follow the each and every step defined in algorithm. They have freedom to skip a step but the order of steps are preserved by template method.

Example:

I also explained about ON and Off buttons. These button follows an orderly invocation of methods defined in Template Method.

What if we introduce a one more method in our algorithm that sets the Duration of the timer. That means when a Switch-On button is pressed, it asks user to set the timer duration for which an equipment must be operational / kept on. But it is upto the equipment if they wish to use this functionality and there is no obligation.

Code: 

public  sealed override void Exceute()
        {
            IsPowerOn();
            CheckTheStatusOfDevice();
            SwitchOnOffDevice();

             if(IsTimerset())
              {
               SetTheTimerDuration();
              }
        }

 In the code above, IsTimerSet is a hook. It contains the default implementation in the abstract class where template method is defined.

protected  virtual bool IsTimerset()
     {
         return false;
     }

Subclasses can override this method but doesn't have to.

public class SwitchOnWaschmachine:ICommand
   {
       private readonly Waschmachine _waschmachine;
       private bool isDeviceOn { get; set; }
       public SwitchOnWaschmachine(Waschmachine waschmachine)
       {
           _waschmachine = waschmachine;
       }


       protected override void SwitchOnOffDevice()
       {
           if (isDeviceOn)
           {
               Console.WriteLine("Device is Already On");
           }
           else
           {
               _waschmachine.SwitchOn();

           }
       }

       protected override void CheckTheStatusOfDevice()
       {
           if (_waschmachine._deviceStatus)
               isDeviceOn = true;
           else
               isDeviceOn = false;
       }

       protected override bool IsTimerset()
       {
           bool shouldTimerBeSet = getUserInput();

           return shouldTimerBeSet;
       }

       public override string ToString()
       {
           return "Washing Machine";
       }

       private bool getUserInput()
       {
           do
           {
               DialogResult dialogResult=MessageBox.Show("Do you want to set the time?", "Remote Control", MessageBoxButtons.YesNo);
               string userInput = Console.ReadLine();
               var timer = dialogResult== DialogResult.Yes ? enumTimer.Yes : enumTimer.No;

               switch (timer)
               {
                   case enumTimer.Yes:
                       return true;
                   case enumTimer.No:
                       return false;
               }
           } while (true);
       }

       protected override void SetTheTimerDuration()
       {
           MessageBox.Show("Timer is set for default duration");
       }
   }

 To use the hook, it is overriden in the subclass and subclasses provides their own functionality.

 

Summary

Use abstract method when your subclass MUST provide an implementation of the method or step in algorithm. Hooks should be used when a certain step is optional. With hooks, there is no obligation for subclasses to implement them. They can if they wish to.