正文

掌握.NET编程，这5大模式让你高效又安全

/0 浏览量
0414

在.NET编程的世界里，掌握一些核心的模式不仅能够提高你的编程效率，还能让你的代码更加安全可靠。下面，我将详细介绍五种对于.NET开发者来说至关重要的编程模式。

1. 单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供一个全局访问点。这在需要全局访问某个资源时非常有用，比如数据库连接。

public class DatabaseConnection
{
    private static DatabaseConnection instance;
    private static readonly object padlock = new object();

    DatabaseConnection() { /* 初始化代码 */ }

    public static DatabaseConnection Instance
    {
        get
        {
            if (instance == null)
            {
                lock (padlock)
                {
                    if (instance == null)
                    {
                        instance = new DatabaseConnection();
                    }
                }
            }
            return instance;
        }
    }
}

2. 工厂模式（Factory Method）

工厂模式定义了一个接口用于创建对象，但让子类决定实例化哪个类。工厂方法让类的设计更加灵活，易于扩展。

public interface IProduct
{
    void Use();
}

public class ConcreteProductA : IProduct
{
    public void Use()
    {
        Console.WriteLine("Using ConcreteProductA");
    }
}

public class ConcreteProductB : IProduct
{
    public void Use()
    {
        Console.WriteLine("Using ConcreteProductB");
    }
}

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("Unknown product type");
        }
    }
}

3. 依赖注入（Dependency Injection）

依赖注入是一种设计模式，它允许你将依赖关系从代码中分离出来，从而提高代码的可测试性和可维护性。

public interface ILogService
{
    void Log(string message);
}

public class FileLogService : ILogService
{
    public void Log(string message)
    {
        // 写入日志到文件
    }
}

public class UserService
{
    private readonly ILogService _logService;

    public UserService(ILogService logService)
    {
        _logService = logService;
    }

    public void RegisterUser(string username)
    {
        _logService.Log($"User {username} registered.");
    }
}

4. 观察者模式（Observer）

观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会得到通知并自动更新。

public interface IObserver
{
    void Update(object sender, EventArgs e);
}

public interface ISubject
{
    void RegisterObserver(IObserver observer);
    void NotifyObservers();
}

public class ConcreteSubject : ISubject
{
    private List<IObserver> _observers = new List<IObserver>();

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

    public void NotifyObservers()
    {
        foreach (var observer in _observers)
        {
            observer.Update(this, EventArgs.Empty);
        }
    }
}

public class ConcreteObserver : IObserver
{
    public void Update(object sender, EventArgs e)
    {
        Console.WriteLine("Observer notified!");
    }
}

5. 命令模式（Command）

命令模式将请求封装为一个对象，从而允许用户使用不同的请求、队列或日志请求，以及支持可撤销的操作。

public interface ICommand
{
    void Execute();
}

public class ConcreteCommand : ICommand
{
    private readonly Receiver _receiver;

    public ConcreteCommand(Receiver receiver)
    {
        _receiver = receiver;
    }

    public void Execute()
    {
        _receiver.DoSomething();
    }
}

public class Receiver
{
    public void DoSomething()
    {
        Console.WriteLine("Receiver does something.");
    }
}

public class Client
{
    public void ExecuteCommand()
    {
        Receiver receiver = new Receiver();
        ICommand command = new ConcreteCommand(receiver);
        command.Execute();
    }
}

通过掌握这些模式，你将能够在.NET编程中更加高效和安全地工作。记住，设计模式不是银弹，但它们是解决常见问题的有力工具。

-- 展开阅读全文 --