Dispatcher Design Pattern

Giới thiệu

Dispatcher Design Pattern là một mẫu thiết kế phần mềm thuộc nhóm hành vi (behavioral design pattern) được sử dụng để quản lý và điều phối các tasks, events, hoặc notification giữa các thành phần trong hệ thống. Mục tiêu chính của Dispatcher Pattern là giảm sự phụ thuộc trực tiếp giữa các thành phần, từ đó tăng tính tái sử dụng và linh hoạt của mã nguồn.

So sánh Dispatcher với Service

Tạo chương trình Console Application gồm có 2 Component A và B đều có hàm HanndleEvent().

namespace DispatcherDesignPattern.ServiceA;

public class ComponentA
{
    public void HandleEvent()
    {
        Console.WriteLine("ComponentA handles event");
    }
}

namespace DispatcherDesignPattern.ServiceB;

public class ComponentB
{
    public void HandleEvent()
    {
        Console.WriteLine("ComponentB handles event");
    }
}

Trong ví dụ đầu tiên, chúng ta tạo thêm Service EventService để gọi 2 hàm HandleEvent() của ComponentA và ComponentB. Chúng ta cần khai báo ComponentA và ComponentB trong EventService.

using DispatcherDesignPattern.ServiceA;
using DispatcherDesignPattern.ServiceB;

namespace DispatcherDesignPattern;

public class EventService
{
    public void NotifyEvent()
    {
        ComponentA componentA = new ComponentA();
        componentA.HandleEvent();

        ComponentB componentB = new ComponentB();
        componentB.HandleEvent();
    }
}

Ở hàm main(), bạn gọi

using DispatcherDesignPattern;
EventService eventService = new EventService();
eventService.NotifyEvent();

Đoạn code dưới đây là 1 cách implement theoDispatch Design Pattern

namespace DispatcherDesignPattern;

public class EventDispatcher
{
    private readonly Dictionary<string, List<Action>> _subscribers = new Dictionary<string, List<Action>>();

    public void Subscribe(string eventName, Action handler)
    {
        if (!_subscribers.ContainsKey(eventName))
        {
            _subscribers[eventName] = new List<Action>();
        }

        _subscribers[eventName].Add(handler);
    }

    public void Dispatch(string eventName)
    {
        if (_subscribers.ContainsKey(eventName))
        {
            foreach (var handler in _subscribers[eventName])
            {
                handler.Invoke();
            }
        }
    }
}

using DispatcherDesignPattern.ServiceA;
using DispatcherDesignPattern.ServiceB;

EventDispatcher eventDispatcher = new EventDispatcher();

ComponentA componentA = new ComponentA();
ComponentB componentB = new ComponentB();

Cả 2 cách đều cho kết quả:

ComponentA handles event
ComponentB handles event

Trong ví dụ trên, Dispatcher quản lý việc register và gửi event đến các subscriber. Chương trình trên minh họa cách sử dụng Dispatcher Pattern để gửi các message có loại khác nhau đến các subscriber tương ứng.

Với cách gọi bằng Dispatcher, cách thành phần không cần biết sự tồn tại của nhau. Dispatcher quản lý event và component chỉ cần đăng ký với Dispatcher mà không cần biết về các thành phần khác. Điều này giảm sự phụ thuộc (dependency) trực tiếp giữa các component.

Trong cách gọi từ Dispatcher, để thêm một thành phần mới (vd như service), bạn chỉ cần đăng ký nó với Dispatcher mà không làm ảnh hưởng đến code của các thành phần khác. Điều này tăng tính tái sử dụng và giảm độ phức tạp của source code.

Implement Dispatcher bằng IHandler

Khai báo IHandler

public interface IHandler
{
    bool CanHandle(object command);
    void Handle(object command);
}

public class CommandDispatcher
{
    private readonly List<IHandler> _handlers;

    public CommandDispatcher()
    {
        _handlers = new List<IHandler>();
    }

    public void RegisterHandler(IHandler handler)
    {
        _handlers.Add(handler);
    }

    public void Dispatch(object command)
    {
        var handler = _handlers.Find(t=>t.CanHandle(command));
        if (handler != null)
        {
            handler.Handle(command);
        }
    }
}

Tạo CreateCustomerHandler

public class CreateCustomerHandler : IHandler
{
    public bool CanHandle(object command)
    {
        return command is CreateCustomerCommand;
    }

    public void Handle(object command)
    {
        if (CanHandle(command))
        {
            var createCustomerCommand = (CreateCustomerCommand)command;
            Console.WriteLine($"Creating customer: {createCustomerCommand.CustomerName}");
        }
    }
}

public class CreateCustomerCommand
{
    public string CustomerName { get; set; }

    public CreateCustomerCommand(string customerName)
    {
        CustomerName = customerName;
    }
}

Ở Program.cs, bạn thêm đoạn code sau để gọi command:

CommandDispatcher commandDispatcher = new CommandDispatcher();
CreateCustomerHandler createCustomerHandler = new CreateCustomerHandler();

// register Handler with Dispatcher
commandDispatcher.RegisterHandler(createCustomerHandler);

// Create a new Command and send it to Dispatcher
CreateCustomerCommand createCustomerCommand = new CreateCustomerCommand("Nhatkyhoctap");
commandDispatcher.Dispatch(createCustomerCommand);

Kết quả

Creating customer: Nhatkyhoctap