C# 面试问题高级：052 - 什么是仓储模式（Repository Pattern） ？
在现代软件开发中，数据访问层的设计和实现变得越来越复杂。为了更好地分离关注点、提高代码的可维护性和测试性，许多设计模式应运而生。仓储模式（Repository Pattern）是其中一种非常流行的设计模式，特别适用于数据持久化操作。
1. 什么是仓储模式？
1.1 定义
仓储模式是一种设计模式，用于抽象和封装数据访问逻辑。它将数据访问的具体实现与业务逻辑分离，使得应用程序可以更容易地进行单元测试和维护。
仓储模式的核心思想是将数据访问逻辑封装在一个称为“仓储”的类中，该类提供了对数据源的标准接口。这样，业务逻辑层可以通过调用仓储接口来访问数据，而无需关心底层的数据存储细节。
1.2 基本概念
- 仓储（Repository）：负责封装数据访问逻辑，提供对数据源的标准接口。
- 实体（Entity）：表示应用程序中的一个对象或记录，通常映射到数据库表。
- 单元操作（Unit of Work）：负责管理事务和持久化操作，确保数据的一致性和完整性。
1.3 示例场景
假设我们需要开发一个简单的电子商务系统，允许用户查看商品信息、添加商品到购物车并下单。我们可以使用仓储模式来实现数据访问层，从而更好地分离关注点，提高代码的可维护性和测试性。
2. 实现仓储模式
下面我们将通过一个具体的例子来展示如何在 C# 中实现仓储模式。
2.1 创建实体类
首先，我们定义一个简单的商品实体类 Product，用于表示商品的信息。
// Product.cs
public class Product
{
public int Id { get; set; } // 商品ID
public string Name { get; set; } // 商品名称
public decimal Price { get; set; } // 商品价格
public override string ToString()
{
return $"Id: {Id}, Name: {Name}, Price: {Price}";
}
}2.2 创建仓储接口
接下来，我们创建一个仓储接口 IProductRepository，定义了对商品的基本操作方法。
// IProductRepository.cs
using System.Collections.Generic;
public interface IProductRepository
{
// 获取所有商品
List GetAllProducts();
// 根据ID获取商品
Product GetProductById(int id);
// 添加商品
void AddProduct(Product product);
// 更新商品
void UpdateProduct(Product product);
// 删除商品
void DeleteProduct(int id);
} 2.3 实现仓储类
然后，我们实现一个具体的仓储类 ProductRepository，负责与数据源进行交互。
// ProductRepository.cs
using System;
using System.Collections.Generic;
public class ProductRepository : IProductRepository
{
private readonly List products = new List();
// 获取所有商品
public List GetAllProducts()
{
return products;
}
// 根据ID获取商品
public Product GetProductById(int id)
{
return products.Find(p => p.Id == id);
}
// 添加商品
public void AddProduct(Product product)
{
if (products.Exists(p => p.Id == product.Id))
{
throw new ArgumentException("商品ID已存在");
}
products.Add(product);
}
// 更新商品
public void UpdateProduct(Product product)
{
var existingProduct = GetProductById(product.Id);
if (existingProduct != null)
{
existingProduct.Name = product.Name;
existingProduct.Price = product.Price;
}
else
{
throw new ArgumentException("找不到指定的商品");
}
}
// 删除商品
public void DeleteProduct(int id)
{
var product = GetProductById(id);
if (product != null)
{
products.Remove(product);
}
else
{
throw new ArgumentException("找不到指定的商品");
}
}
} 2.4 使用仓储类
接下来，我们在主程序中使用上述仓储类，并观察其行为。
// Program.cs
class Program
{
static void Main(string[] args)
{
IProductRepository repository = new ProductRepository();
// 添加商品
repository.AddProduct(new Product { Id = 1, Name = "Apple", Price = 0.5m });
repository.AddProduct(new Product { Id = 2, Name = "Banana", Price = 0.3m });
// 获取所有商品
var allProducts = repository.GetAllProducts();
Console.WriteLine("所有商品:");
foreach (var product in allProducts)
{
Console.WriteLine(product); // 输出商品信息
}
// 根据ID获取商品
var productById = repository.GetProductById(1);
Console.WriteLine($"根据ID获取的商品: {productById}");
// 更新商品
var updatedProduct = new Product { Id = 1, Name = "Golden Apple", Price = 0.6m };
repository.UpdateProduct(updatedProduct);
Console.WriteLine($"更新后的商品: {repository.GetProductById(1)}");
// 删除商品
repository.DeleteProduct(2);
Console.WriteLine("删除后的商品列表:");
foreach (var product in repository.GetAllProducts())
{
Console.WriteLine(product); // 输出剩余商品信息
}
}
}2.5 执行结果
运行上述代码后，输出结果如下：
所有商品:
Id: 1, Name: Apple, Price: 0.5
Id: 2, Name: Banana, Price: 0.3
根据ID获取的商品: Id: 1, Name: Apple, Price: 0.5
更新后的商品: Id: 1, Name: Golden Apple, Price: 0.6
删除后的商品列表:
Id: 1, Name: Golden Apple, Price: 0.63. 仓储模式的高级用法
为了更好地理解仓储模式的高级用法，我们可以进一步扩展上面的例子，引入更多复杂的场景和功能。
3.1 使用依赖注入
依赖注入（Dependency Injection, DI）是一种设计模式，用于将依赖项传递给类，而不是让类自己创建依赖项。这有助于提高代码的可测试性和可维护性。
首先，我们需要安装一个依赖注入框架，如 Microsoft.Extensions.DependencyInjection。
dotnet add package Microsoft.Extensions.DependencyInjection然后，我们可以在主程序中配置依赖注入容器。
// Program.cs
using Microsoft.Extensions.DependencyInjection;
class Program
{
static void Main(string[] args)
{
var serviceProvider = new ServiceCollection()
.AddSingleton() // 注册仓储服务
.BuildServiceProvider();
IProductRepository repository = serviceProvider.GetService();
// 添加商品
repository.AddProduct(new Product { Id = 1, Name = "Apple", Price = 0.5m });
repository.AddProduct(new Product { Id = 2, Name = "Banana", Price = 0.3m });
// 获取所有商品
var allProducts = repository.GetAllProducts();
Console.WriteLine("所有商品:");
foreach (var product in allProducts)
{
Console.WriteLine(product); // 输出商品信息
}
// 根据ID获取商品
var productById = repository.GetProductById(1);
Console.WriteLine($"根据ID获取的商品: {productById}");
// 更新商品
var updatedProduct = new Product { Id = 1, Name = "Golden Apple", Price = 0.6m };
repository.UpdateProduct(updatedProduct);
Console.WriteLine($"更新后的商品: {repository.GetProductById(1)}");
// 删除商品
repository.DeleteProduct(2);
Console.WriteLine("删除后的商品列表:");
foreach (var product in repository.GetAllProducts())
{
Console.WriteLine(product); // 输出剩余商品信息
}
}
} 3.2 使用单元操作（Unit of Work）
单元操作（Unit of Work）是一种设计模式，用于管理事务和持久化操作，确保数据的一致性和完整性。
首先，我们定义一个单元操作接口 IUnitOfWork，并在仓储类中使用它。
// IUnitOfWork.cs
public interface IUnitOfWork
{
void Commit(); // 提交事务
}
// UnitOfWork.cs
public class UnitOfWork : IUnitOfWork
{
public void Commit()
{
// 在这里实现提交事务的逻辑
Console.WriteLine("事务已提交");
}
}
// ProductRepository.cs
public class ProductRepository : IProductRepository
{
private readonly List products = new List();
private readonly IUnitOfWork unitOfWork;
public ProductRepository(IUnitOfWork unitOfWork)
{
this.unitOfWork = unitOfWork;
}
public List GetAllProducts()
{
return products;
}
public Product GetProductById(int id)
{
return products.Find(p => p.Id == id);
}
public void AddProduct(Product product)
{
if (products.Exists(p => p.Id == product.Id))
{
throw new ArgumentException("商品ID已存在");
}
products.Add(product);
unitOfWork.Commit(); // 提交事务
}
public void UpdateProduct(Product product)
{
var existingProduct = GetProductById(product.Id);
if (existingProduct != null)
{
existingProduct.Name = product.Name;
existingProduct.Price = product.Price;
unitOfWork.Commit(); // 提交事务
}
else
{
throw new ArgumentException("找不到指定的商品");
}
}
public void DeleteProduct(int id)
{
var product = GetProductById(id);
if (product != null)
{
products.Remove(product);
unitOfWork.Commit(); // 提交事务
}
else
{
throw new ArgumentException("找不到指定的商品");
}
}
} 然后，我们在主程序中使用单元操作。
// Program.cs
using Microsoft.Extensions.DependencyInjection;
class Program
{
static void Main(string[] args)
{
var serviceProvider = new ServiceCollection()
.AddSingleton()
.AddSingleton() // 注订单元操作服务
.BuildServiceProvider();
IProductRepository repository = serviceProvider.GetService();
// 添加商品
repository.AddProduct(new Product { Id = 1, Name = "Apple", Price = 0.5m });
repository.AddProduct(new Product { Id = 2, Name = "Banana", Price = 0.3m });
// 获取所有商品
var allProducts = repository.GetAllProducts();
Console.WriteLine("所有商品:");
foreach (var product in allProducts)
{
Console.WriteLine(product); // 输出商品信息
}
// 根据ID获取商品
var productById = repository.GetProductById(1);
Console.WriteLine($"根据ID获取的商品: {productById}");
// 更新商品
var updatedProduct = new Product { Id = 1, Name = "Golden Apple", Price = 0.6m };
repository.UpdateProduct(updatedProduct);
Console.WriteLine($"更新后的商品: {repository.GetProductById(1)}");
// 删除商品
repository.DeleteProduct(2);
Console.WriteLine("删除后的商品列表:");
foreach (var product in repository.GetAllProducts())
{
Console.WriteLine(product); // 输出剩余商品信息
}
}
} 3.3 使用异步操作
在现代应用程序中，异步操作是非常常见的。我们可以将仓储类中的同步方法转换为异步方法，以提高应用程序的响应性能。
首先，我们修改仓储接口，使其支持异步操作。
// IProductRepository.cs
using System.Collections.Generic;
using System.Threading.Tasks;
public interface IProductRepository
{
Task> GetAllProductsAsync();
Task GetProductByIdAsync(int id);
Task AddProductAsync(Product product);
Task UpdateProductAsync(Product product);
Task DeleteProductAsync(int id);
} 然后，我们实现异步版本的仓储类。
// ProductRepository.cs
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
public class ProductRepository : IProductRepository
{
private readonly List products = new List();
public async Task> GetAllProductsAsync()
{
await Task.Delay(100); // 模拟异步操作
return products;
}
public async Task GetProductByIdAsync(int id)
{
await Task.Delay(100); // 模拟异步操作
return products.FirstOrDefault(p => p.Id == id);
}
public async Task AddProductAsync(Product product)
{
await Task.Delay(100); // 模拟异步操作
if (products.Any(p => p.Id == product.Id))
{
throw new ArgumentException("商品ID已存在");
}
products.Add(product);
}
public async Task UpdateProductAsync(Product product)
{
await Task.Delay(100); // 模拟异步操作
var existingProduct = await GetProductByIdAsync(product.Id);
if (existingProduct != null)
{
existingProduct.Name = product.Name;
existingProduct.Price = product.Price;
}
else
{
throw new ArgumentException("找不到指定的商品");
}
}
public async Task DeleteProductAsync(int id)
{
await Task.Delay(100); // 模拟异步操作
var product = await GetProductByIdAsync(id);
if (product != null)
{
products.Remove(product);
}
else
{
throw new ArgumentException("找不到指定的商品");
}
}
} 最后，我们在主程序中使用异步方法。
// Program.cs
using Microsoft.Extensions.DependencyInjection;
using System.Threading.Tasks;
class Program
{
static async Task Main(string[] args)
{
var serviceProvider = new ServiceCollection()
.AddSingleton()
.BuildServiceProvider();
IProductRepository repository = serviceProvider.GetService();
// 添加商品
await repository.AddProductAsync(new Product { Id = 1, Name = "Apple", Price = 0.5m });
await repository.AddProductAsync(new Product { Id = 2, Name = "Banana", Price = 0.3m });
// 获取所有商品
var allProducts = await repository.GetAllProductsAsync();
Console.WriteLine("所有商品:");
foreach (var product in allProducts)
{
Console.WriteLine(product); // 输出商品信息
}
// 根据ID获取商品
var productById = await repository.GetProductByIdAsync(1);
Console.WriteLine($"根据ID获取的商品: {productById}");
// 更新商品
var updatedProduct = new Product { Id = 1, Name = "Golden Apple", Price = 0.6m };
await repository.UpdateProductAsync(updatedProduct);
Console.WriteLine($"更新后的商品: {await repository.GetProductByIdAsync(1)}");
// 删除商品
await repository.DeleteProductAsync(2);
Console.WriteLine("删除后的商品列表:");
var remainingProducts = await repository.GetAllProductsAsync();
foreach (var product in remainingProducts)
{
Console.WriteLine(product); // 输出剩余商品信息
}
}
} 4. 仓储模式的优缺点
优点
-
分离关注点：
- 业务逻辑与数据访问分离：仓储模式通过将数据访问逻辑封装在仓库类中，使得业务逻辑代码可以专注于处理业务规则，而不必关心具体的数据访问细节。
- 减少依赖：业务逻辑层不需要直接依赖于具体的数据库或数据访问技术，从而降低了耦合度。
-
提高可测试性：
- 单元测试更容易：由于仓储模式将数据访问逻辑与业务逻辑分离，因此可以通过模拟（Mock）仓库来编写单元测试，而无需依赖真实的数据库。
- 简化测试数据准备：可以在测试中轻松地提供假数据，而不必依赖外部数据源。
-
增强灵活性：
- 支持多种数据源：仓储模式允许应用程序轻松切换不同的数据源（如从SQL数据库切换到NoSQL数据库），只需修改仓库的具体实现即可。
- 易于扩展：当需要添加新的数据访问功能时，只需在仓库类中添加相应的方法，而不会影响业务逻辑层。
-
统一接口：
- 一致的数据访问方式：通过定义统一的仓库接口，所有数据访问操作都遵循相同的模式，提高了代码的一致性和可读性。
- 简化复杂查询：复杂的查询逻辑可以封装在仓库类中，业务逻辑层只需要调用相应的仓库方法即可。
缺点
-
学习曲线：
- 对于初学者来说，理解和实现仓储模式可能需要一些时间，特别是涉及到依赖注入和接口设计时。
-
额外的抽象层：
- 仓储模式引入了额外的抽象层，这可能会增加项目的复杂性，特别是在小型项目中，这种复杂性可能显得不必要。
-
性能开销：
- 在某些情况下，频繁的数据访问操作可能会带来一定的性能开销，尤其是在高并发场景下。
-
过度设计的风险：
- 如果项目规模较小或数据访问需求简单，使用仓储模式可能会导致过度设计，增加不必要的代码量。
5.总结
仓储模式是一种非常强大的设计模式，它能够有效地分离业务逻辑与数据访问逻辑，提高代码的可维护性和测试性。通过使用仓储模式，开发者可以以一种简洁的方式实现复杂的数据访问逻辑，适用于多种类型的应用场景。尽管仓储模式有一些缺点，如增加了系统的复杂性和学习曲线，但这些问题可以通过合理的设计和优化来缓解。