【读书活动感悟分享】特能扛——《设计模式：可复用面向对象软件的基础》第3章 原型模式 - 3.4

一、原型模式概述

原型模式（Prototype Pattern）是一种创建型设计模式，其核心思想是通过复制（克隆）已有对象（原型）来创建新对象，而非通过构造函数重新初始化。

在该模式中，新对象的初始状态与原型完全一致，后续可根据需求修改自身属性。这种方式绕开了复杂的初始化流程（如数据库查询、资源加载等），直接复用原型的状态，从而减少重复劳动，提高对象创建效率。

原型模式的核心角色包括：

• 抽象原型（Prototype）：定义克隆方法的接口（通常为 Clone() 方法）；
• 具体原型（Concrete Prototype）：实现抽象原型的克隆方法，返回自身的副本；
• 客户端（Client）：通过调用原型的克隆方法创建新对象，无需关注对象的具体创建逻辑。

二、原型模式的使用场景

三、原型模式的优缺点

优点

缺点

四、使用原型模式的注意事项

五、示例代码

using System;
using System.Collections.Generic;
// 原型接口（实现ICloneable或自定义克隆方法）
public interface IPrototype<T>
{
T Clone();
}
// 具体原型类（可克隆对象）
public class Product : IPrototype<Product>
{
public int Id { get; set; }
public string Name { get; set; }
public decimal Price { get; set; }
public List<string> Tags { get; set; } // 引用类型成员
public Product(int id, string name, decimal price, List<string> tags)
{
Id = id;
Name = name;
Price = price;
Tags = tags;
}
// 深克隆实现（复制值类型+引用类型深拷贝）
public Product Clone()
{
// 对引用类型成员进行深拷贝
List<string> clonedTags = new List<string>(Tags);
return new Product(Id, Name, Price, clonedTags);
}
public override string ToString()
{
return $"Id: {Id}, Name: {Name}, Price: {Price}, Tags: [{string.Join(", ", Tags)}]";
}
}
// 客户端调用示例
public class Client
{
public static void Main()
{
// 创建原始对象
var originalTags = new List<string> { "电子", "数码", "新品" };
Product originalProduct = new Product(1, "智能手机", 3999.99m, originalTags);
Console.WriteLine("原始对象：" + originalProduct);
// 通过原型克隆新对象
Product clonedProduct = originalProduct.Clone();
Console.WriteLine("\n克隆对象（初始状态）：" + clonedProduct);
// 修改克隆对象的属性（验证深克隆：引用类型修改不影响原始对象）
clonedProduct.Id = 2;
clonedProduct.Name = "高端智能手机";
clonedProduct.Price = 5999.99m;
clonedProduct.Tags.Add("旗舰");
Console.WriteLine("\n修改后的克隆对象：" + clonedProduct);
Console.WriteLine("修改后原始对象：" + originalProduct);
}
}

六、原型模式与使用new关键字创建对象的区别

原型模式与通过 new关键字创建对象（即直接实例化）是两种不同的对象创建方式，核心区别体现在创建逻辑、效率、适用场景等方面。以下从多个维度对比两者的差异：

(1)、核心思想不同

• new 关键字创建对象
  基于类的构造函数初始化新对象，本质是“从无到有”创建：先分配内存，再执行构造函数中的初始化逻辑（如设置初始值、调用方法、依赖外部资源等），最终生成一个全新的对象。
  例如：var obj = new MyClass(param1, param2); 会严格按照 MyClass 的构造函数逻辑执行。
• 原型模式
  基于已有对象（原型）的“克隆”创建新对象，本质是“复制已有”：直接复制原型对象的内存数据（或深度复制其状态），生成一个与原型初始状态一致的新对象，跳过构造函数的执行。
  例如：var obj = prototype.Clone(); 复用原型的状态，无需重新执行初始化逻辑。

(2)、创建过程不同

(3)、效率不同

• new 关键字创建对象
  若对象初始化逻辑简单（如仅设置几个值类型属性），效率与克隆接近；
  若初始化逻辑复杂（如查询数据库、读取大文件、复杂计算），频繁 new 会重复执行这些操作，导致效率低下。
• 原型模式
  克隆过程本质是内存数据的复制（浅克隆）或序列化/反序列化（深克隆），跳过了重复的初始化逻辑，因此在以下场景效率更高：
  • 需频繁创建相似对象（如游戏中批量生成同类型怪物）；
  • 初始化成本高的对象（如包含大量配置的复杂对象）。

(4)、灵活性不同

• new 关键字创建对象
  灵活性较低：
  • 编译期需确定具体类型，无法动态切换（如 new A()不能在运行时改为 new B()）；
  • 若需创建多个相似但略有差异的对象，需重复编写初始化代码（如多次调用 new 并修改部分属性）。
• 原型模式
  灵活性更高：
  • 运行时可动态切换原型（如通过“原型管理器”选择不同原型克隆），无需修改客户端代码；
  • 克隆后只需修改少量属性即可生成变体，减少重复代码（符合“开闭原则”）。

(5)、适用场景不同

对象快照（Object Snapshot）： 某一时刻内存中对象的 “静态副本”。

(6)、代码示例对比

场景：创建“用户订单”对象，包含订单信息和用户信息（引用类型）。

1. 使用 new 关键字创建public class User
{
public string Name { get; set; }
public int Age { get; set; }
public User(string name, int age)
{
// 模拟复杂初始化（如查询用户等级）
Console.WriteLine("执行User构造函数，查询用户等级...");
Name = name;
Age = age;
}
}
public class Order
{
public int Id { get; set; }
public decimal Amount { get; set; }
public User Buyer { get; set; }
public Order(int id, decimal amount, User buyer)
{
// 模拟复杂初始化（如校验订单金额）
Console.WriteLine("执行Order构造函数，校验金额...");
Id = id;
Amount = amount;
Buyer = buyer;
}
}
// 客户端
var user = new User("张三", 30);
// 多次创建相似订单（每次都执行构造函数）
var order1 = new Order(1, 100, user);
var order2 = new Order(2, 200, user); // 重复执行校验逻辑，效率低

输出（构造函数被多次执行）：

执行User构造函数，查询用户等级...
执行Order构造函数，校验金额...
执行Order构造函数，校验金额...
2. 使用原型模式创建public class User
{
public string Name { get; set; }
public int Age { get; set; }
public User(string name, int age)
{
Console.WriteLine("执行User构造函数，查询用户等级...");
Name = name;
Age = age;
}
}
public class Order : ICloneable
{
public int Id { get; set; }
public decimal Amount { get; set; }
public User Buyer { get; set; }
public Order(int id, decimal amount, User buyer)
{
Console.WriteLine("执行Order构造函数，校验金额...");
Id = id;
Amount = amount;
Buyer = buyer;
}
// 浅克隆（示例）
public object Clone() => this.MemberwiseClone();
}
// 客户端
var user = new User("张三", 30);
var prototypeOrder = new Order(1, 100, user); // 仅执行一次构造函数
// 克隆生成新订单（不执行构造函数）
var order2 = (Order)prototypeOrder.Clone();
order2.Id = 2;
order2.Amount = 200;

输出（构造函数仅执行一次）：

执行User构造函数，查询用户等级...
执行Order构造函数，校验金额...

• new 关键字是最基础的对象创建方式，适合初始化简单、类型固定、创建频率低的场景，直接依赖类的构造函数，逻辑直观但灵活性和效率有限。
• 原型模式是对 new 的补充，适合初始化复杂、需频繁创建相似对象或动态生成对象的场景，通过克隆复用原型状态，效率更高、灵活性更强，但需处理浅克隆/深克隆的细节。

实际开发中，两者并非互斥：简单对象用 new，复杂且重复创建的对象用原型模式，需根据具体场景权衡选择。

七、原型模式在特来电业务中可应用的场景

1.电站信息创建，目前电站有多种，普通电站、光伏电站、储能站、互联互通电站。 基本信息有很多是一样的，只是有个别属性不一致。在构建电站信息时，可使用原型模式。

2.价格策略创建，与电站类似，价格策略也是有多种不同的策略，普通策略、接入电价策略、超时占用费策略、折扣策略等，在创建策略信息时，也可使用原型模式。

八、总结思考

原型模式通过 “克隆” 实现对象创建，是一种高效的 “以空间换时间” 的设计思想。其核心价值在于复用已有对象的状态，减少重复初始化操作，尤其适合处理创建成本高或需频繁生成相似对象的场景。

从实践角度看，使用原型模式需注意以下几点：

总之，原型模式是对传统对象创建方式的有效补充，合理使用可显著提升系统性能和灵活性，但需权衡其实现复杂度与业务需求的匹配度，避免为了设计而设计。