Design Pattern – Ví dụ về Service Locator trong C#

Service Locator là một design pattern thông dụng cho phép tách rời (decouple) một class với các dependency (hay được gọi là service) của nó. Service Locator có thể coi là một đối tượng trung gian trong việc liên kết class và các dependency.

Giới thiệu

Serive Locator pattern mô tả cách để đăng ký và lấy các dependency để sử dụng. Bạn có thể thấy pattern này là một dạng kết hợp của Factory pattern và Dependency Injection pattern. Một số lợi ích mà pattern này đem lại:

– Tách rời một class với các dependency của nó, nhờ đó có thể dễ dàng thay thế các dependency.
– Các dependency sẽ được sử dụng dưới dạng interface, đảm bảo không sử dụng các class cụ thể (concrete)của dependency.
– Dễ dàng test các class trong môi trường cách ly (isolation), không phụ thuộc vào các dependency.
– Các đoạn code để tạo, quản lý dependency được tách riêng ra khỏi các class.
– Ứng dụng có thể được chia ra các phần ít bị ràng buộc (loosely coupled) với nhau.

Mặc dù có nhiều lợi ích rõ ràng như vậy nhưng pattern cũng có một số hạn chế và nhiều ý kiến trái chiều. Tuy nhiên bài viết này chỉ tập trung vào giới thiệu và minh họa cơ chế làm việc của nó.

Hiện thực một Service Locator

Dưới đây là một ví dụ cách hiện thực lớp Service Locator sử dụng generic trong C#. Nó chứa hai phương thức quan trọng mà bạn cần quan tâm:
– Register<T>: đăng ký một dependency dựa trên kiểu của interface (T) và một instance hiện thực từ interface đó (service). Service Locator sẽ giữ lại trong cache để trả về khi được yêu cầu.

– GetService<T>(): trả về một service được đăng ký với kiểu T.

public class ServiceLocator
{
	private static readonly IDictionary<Type, object> _serviceCache;
	private static ServiceLocator _instance;

	static ServiceLocator()
	{
		_serviceCache = new Dictionary<Type, object> ();
	}

	public static ServiceLocator Instance
	{
		get
		{
			if (_instance == null)
			{
				_instance = new ServiceLocator();
			}

			return _instance;
		}
	}

	public void Register<T>(T service)
	{
		var key = typeof(T);
		if (!_serviceCache.ContainsKey(key))
		{
			_serviceCache.Add(key, service);
		}
		else  // overwrite the existing instance.
		{
			_serviceCache[key] = service;
		}
	}

	public T GetService<T>()
	{
		var key = typeof(T);
		if (!_serviceCache.ContainsKey(key))
		{
			throw new ArgumentException(string.Format("Type '{0}' has not been registered.", key.Name));
		}

		return (T)_serviceCache[key];
	}
}

Ví dụ sử dụng

Một ví dụ đơn giản sử dụng ServiceLocator bên trên, interface IOperatingSystem được sử dụng như một dependency. Tôi tạo thêm một class Windows hiện thực từ interface này.

public interface IOperatingSystem
{
	string Name { get; set; }
	void Run();
}

public class Windows : IOperatingSystem
{
	public Windows()
	{
		Name = "Windows XP";
	}

	public string Name { get; set; }

	public void Run()
	{
		Console.WriteLine(Name + " is running.");
	}
}

Tiếp theo là class Computer sẽ sử dụng dependency IOperatingSystem. Trong constructor của class này, tôi sẽ lấy instance của IOperatingSystem từ ServiceLocator, tất nhiên nó phải được đăng ký trước. Với cách này, bạn thấy nó sẽ khác biệt với dependency injection truyền parameter thông qua constructor.

public class Computer
{
	private readonly IOperatingSystem _operatingSystem;

	public Computer()
	{
		_operatingSystem = ServiceLocator.Instance.GetService<IOperatingSystem>();
	}

	public void Start()
	{
		_operatingSystem.Run();
	}
}

Dưới đây là đoạn code chương trình để chạy minh họa. Như bạn thấy việc tạo một instance của Computer rất dễ dàng vì bạn không cần thiết phải tạo và truyền các dependency cho nó.

static void Main(string[] args)
{
	ServiceLocator.Instance.Register<IOperatingSystem>(new Windows());
	
	var computer = new Computer();
	computer.Start();

	Console.Read();
}

Output:

Windows XP is running.

Đọc thêm

The Service Locator Pattern: https://msdn.microsoft.com/en-us/library/ff648968.aspx

YinYangIt Blog