×

Các Mẫu Thiết Kế Phổ Biến Trong Lập Trình C#

Avatar of luongtu
luongtu 3 Views

Trong lập trình, mẫu thiết kế (design patterns) là các giải pháp đã được kiểm chứng cho các vấn đề thường gặp trong thiết kế phần mềm. Sử dụng đúng mẫu thiết kế giúp cải thiện khả năng bảo trì, mở rộng và hiểu mã nguồn. Dưới đây là một số mẫu thiết kế phổ biến và cách sử dụng chúng trong C#.

1. Singleton Pattern

Mẫu Singleton đảm bảo rằng một lớp chỉ có một thể hiện duy nhất và cung cấp một điểm truy cập toàn cục cho thể hiện đó.

public class Singleton
{
    private static Singleton _instance;
    private static readonly object _lock = new object();

    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            lock (_lock)
            {
                if (_instance == null)
                {
                    _instance = new Singleton();
                }
                return _instance;
            }
        }
    }

    public void DoSomething()
    {
        Console.WriteLine("Singleton instance is doing something.");
    }
}

Sử dụng:

Singleton instance = Singleton.Instance;
instance.DoSomething();

2. Factory Pattern

Mẫu Factory cung cấp một giao diện để tạo đối tượng mà không xác định lớp cụ thể của đối tượng đó.

public interface IProduct
{
    void DoWork();
}

public class ConcreteProductA : IProduct
{
    public void DoWork()
    {
        Console.WriteLine("Product A is doing work.");
    }
}

public class ConcreteProductB : IProduct
{
    public void DoWork()
    {
        Console.WriteLine("Product B is doing work.");
    }
}

public class ProductFactory
{
    public static IProduct CreateProduct(string type)
    {
        switch (type)
        {
            case "A": return new ConcreteProductA();
            case "B": return new ConcreteProductB();
            default: throw new ArgumentException("Invalid type");
        }
    }
}

Sử dụng:

IProduct productA = ProductFactory.CreateProduct("A");
productA.DoWork();

IProduct productB = ProductFactory.CreateProduct("B");
productB.DoWork();

3. Observer Pattern

Mẫu Observer cho phép một đối tượng thông báo cho các đối tượng khác về các thay đổi trạng thái của nó.

public interface IObserver
{
    void Update(string message);
}

public class ConcreteObserver : IObserver
{
    private string _name;

    public ConcreteObserver(string name)
    {
        _name = name;
    }

    public void Update(string message)
    {
        Console.WriteLine($"{_name} received message: {message}");
    }
}

public class Subject
{
    private List<IObserver> _observers = new List<IObserver>();

    public void Attach(IObserver observer)
    {
        _observers.Add(observer);
    }

    public void Detach(IObserver observer)
    {
        _observers.Remove(observer);
    }

    public void Notify(string message)
    {
        foreach (var observer in _observers)
        {
            observer.Update(message);
        }
    }
}

Sử dụng:

var subject = new Subject();

var observer1 = new ConcreteObserver("Observer 1");
var observer2 = new ConcreteObserver("Observer 2");

subject.Attach(observer1);
subject.Attach(observer2);

subject.Notify("Hello, Observers!");

subject.Detach(observer1);

subject.Notify("Goodbye, Observer 1!");

4. Decorator Pattern

Mẫu Decorator cho phép bạn thêm hành vi mới vào đối tượng bằng cách bọc đối tượng đó trong một lớp trang trí.

public interface IComponent
{
    void Operation();
}

public class ConcreteComponent : IComponent
{
    public void Operation()
    {
        Console.WriteLine("ConcreteComponent Operation");
    }
}

public abstract class Decorator : IComponent
{
    protected IComponent _component;

    public Decorator(IComponent component)
    {
        _component = component;
    }

    public virtual void Operation()
    {
        _component.Operation();
    }
}

public class ConcreteDecoratorA : Decorator
{
    public ConcreteDecoratorA(IComponent component) : base(component) { }

    public override void Operation()
    {
        base.Operation();
        Console.WriteLine("ConcreteDecoratorA Operation");
    }
}

public class ConcreteDecoratorB : Decorator
{
    public ConcreteDecoratorB(IComponent component) : base(component) { }

    public override void Operation()
    {
        base.Operation();
        Console.WriteLine("ConcreteDecoratorB Operation");
    }
}

Sử dụng:

IComponent component = new ConcreteComponent();
IComponent decoratorA = new ConcreteDecoratorA(component);
IComponent decoratorB = new ConcreteDecoratorB(decoratorA);

decoratorB.Operation();

5. Strategy Pattern

Mẫu Strategy cho phép lựa chọn thuật toán tại runtime. Nó định nghĩa một họ các thuật toán, đóng gói từng cái một, và làm cho chúng có thể thay thế lẫn nhau.

public interface IStrategy
{
    void Execute();
}

public class ConcreteStrategyA : IStrategy
{
    public void Execute()
    {
        Console.WriteLine("Strategy A executed.");
    }
}

public class ConcreteStrategyB : IStrategy
{
    public void Execute()
    {
        Console.WriteLine("Strategy B executed.");
    }
}

public class Context
{
    private IStrategy _strategy;

    public void SetStrategy(IStrategy strategy)
    {
        _strategy = strategy;
    }

    public void ExecuteStrategy()
    {
        _strategy.Execute();
    }
}

Sử dụng:

var context = new Context();

context.SetStrategy(new ConcreteStrategyA());
context.ExecuteStrategy();

context.SetStrategy(new ConcreteStrategyB());
context.ExecuteStrategy();

Tóm Lược

Mẫu thiết kế là các giải pháp đã được kiểm chứng cho các vấn đề phổ biến trong phát triển phần mềm. Bằng cách sử dụng các mẫu thiết kế như Singleton, Factory, Observer, Decorator, và Strategy, bạn có thể tạo ra mã nguồn dễ bảo trì, dễ mở rộng, và dễ hiểu hơn. Hiểu và áp dụng đúng các mẫu thiết kế này sẽ giúp bạn trở thành một lập trình viên C# hiệu quả hơn.

Comments

Bài viết liên quan