ASP.NET MVC最常用的设计模式代码示例

ASP.NET MVC 是一个基于分层架构的框架，其核心架构本身已经实现了 MVC 模式（Model-View-Controller）。除了 MVC 模式，开发者在使用 ASP.NET MVC 开发应用时，通常会结合其他设计模式以提高代码的可维护性、可扩展性和可测试性。

以下是 ASP.NET MVC 中常用的设计模式及其应用场景：

1. MVC 模式

MVC 是 ASP.NET MVC 的核心设计模式，负责分离应用的关注点：

Model：处理业务逻辑和数据。 View：负责显示用户界面。 Controller：处理用户输入并协调 Model 和 View。

应用：

Controller 处理用户请求，并调用 Model 获取数据。 Model 返回数据，Controller 将数据传递给 View。 View 渲染最终的页面。

MVC模式的优点：清晰的职责分离。易于测试（Controller 和 Model 可独立单元测试）。支持多种视图（如 JSON、HTML）。

2. 依赖注入（DI）模式

描述：DI 是控制反转（IoC）的一种实现方式，Controller 等组件依赖的对象由外部注入，而不是自己创建。

应用：通过依赖注入容器（如 Unity、Autofac 或内置的 ASP.NET Core DI 容器）将服务注入到 Controller 中。

public class HomeController : Controller
{
    private readonly IMyService _myService;

    public HomeController(IMyService myService)
    {
        _myService = myService;
    }

    public ActionResult Index()
    {
        var data = _myService.GetData();
        return View(data);
    }
}

依赖注入（DI）模式的优点：提高组件的可测试性。降低组件之间的耦合度。更灵活的依赖管理。

3. 仓储模式（Repository Pattern）

描述：通过一个抽象的仓储层来操作数据，封装对数据库的访问逻辑。

应用：将数据库访问代码从业务逻辑中分离。通过接口定义仓储行为，从而支持单元测试。

public interface IProductRepository
{
    IEnumerable<Product> GetAllProducts();
    Product GetProductById(int id);
}

public class ProductRepository : IProductRepository
{
    private readonly AppDbContext _context;

    public ProductRepository(AppDbContext context)
    {
        _context = context;
    }

    public IEnumerable<Product> GetAllProducts()
    {
        return _context.Products.ToList();
    }

    public Product GetProductById(int id)
    {
        return _context.Products.Find(id);
    }
}

仓储模式（Repository Pattern）的优点：使业务逻辑与数据访问解耦。提供统一的接口，便于切换数据源。

4. 单一职责模式

描述：每个类只负责一个单一功能，避免过多职责集中在同一个类中。

应用：将复杂逻辑分解为多个单一功能的服务或类。

public class EmailService
{
    public void SendEmail(string to, string subject, string body)
    {
        // Email sending logic
    }
}

public class OrderService
{
    private readonly EmailService _emailService;

    public OrderService(EmailService emailService)
    {
        _emailService = emailService;
    }

    public void ProcessOrder(Order order)
    {
        // Order processing logic
        _emailService.SendEmail(order.CustomerEmail, "Order Processed", "Your order is complete.");
    }
}

单一职责模式的优点：增强代码的可维护性。避免类的复杂度过高。

5. 工厂模式（Factory Pattern）

描述：通过工厂类来创建对象，而不是直接使用 new 操作符。这让创建过程更加灵活。

应用：创建复杂对象时使用工厂模式。用于根据条件返回不同类型的实例。

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

public class FileLogger : ILogger
{
    public void Log(string message)
    {
        // Log to file
    }
}

public class LoggerFactory
{
    public static ILogger CreateLogger(string loggerType)
    {
        if (loggerType == "File")
            return new FileLogger();
        // Add other logger types here
        return null;
    }
}

// 使用
var logger = LoggerFactory.CreateLogger("File");
logger.Log("Application started.");

工厂模式（Factory Pattern）的优点：提高代码的可扩展性。解耦对象的创建过程。

6. 单例模式（Singleton Pattern）

描述：确保一个类只有一个实例，并提供一个全局访问点。

应用：用于跨请求共享状态（如配置管理、日志记录等）。

public class ConfigurationManager
{
    private static readonly ConfigurationManager _instance = new ConfigurationManager();

    private ConfigurationManager() { }

    public static ConfigurationManager Instance => _instance;

    public string GetConfigValue(string key)
    {
        // Return config value
        return "value";
    }
}

单例模式（Singleton Pattern）优点：提供唯一实例，节省资源。简化共享数据的管理。

7. 策略模式（Strategy Pattern）

描述：定义一系列算法，并将它们封装起来，使它们可以互换。

应用：在不同的支付方式、排序算法等场景中使用。

public interface IPaymentStrategy
{
    void Pay(decimal amount);
}

public class CreditCardPayment : IPaymentStrategy
{
    public void Pay(decimal amount)
    {
        Console.WriteLine($"Paid {amount} using Credit Card.");
    }
}

public class PayPalPayment : IPaymentStrategy
{
    public void Pay(decimal amount)
    {
        Console.WriteLine($"Paid {amount} using PayPal.");
    }
}

public class PaymentProcessor
{
    private readonly IPaymentStrategy _paymentStrategy;

    public PaymentProcessor(IPaymentStrategy paymentStrategy)
    {
        _paymentStrategy = paymentStrategy;
    }

    public void ProcessPayment(decimal amount)
    {
        _paymentStrategy.Pay(amount);
    }
}

// 使用
var processor = new PaymentProcessor(new PayPalPayment());
processor.ProcessPayment(100.00m);

策略模式（Strategy Pattern）的优点：提供灵活的算法切换机制。符合开放/封闭原则。

8. 观察者模式（Observer Pattern）

描述：当一个对象的状态改变时，自动通知所有依赖它的对象。

应用：常用于事件处理机制，例如用户注册成功后发送通知邮件或更新日志。

public class User
{
    public event Action UserRegistered;

    public void Register()
    {
        Console.WriteLine("User registered.");
        UserRegistered?.Invoke();
    }
}

public class EmailNotifier
{
    public void OnUserRegistered()
    {
        Console.WriteLine("Sending notification email.");
    }
}

// 使用
var user = new User();
var emailNotifier = new EmailNotifier();

user.UserRegistered += emailNotifier.OnUserRegistered;
user.Register();

观察者模式（Observer Pattern）的优点：实现事件驱动编程。易于扩展新的监听者。

通过合理组合这些设计模式，可以大幅提升 ASP.NET MVC 项目的代码质量和可维护性。

更新于：5天前