表面模式：简化复杂体系的优雅办理方案

1. 表面模式概述

表面模式(Facade Pattern)是一种布局型筹划模式，它为子体系中的一组接口提供一个统一的高层接口，使子体系更加容易利用。表面模式定义了一个高层接口，这个接口使得子体系更加容易利用，从而简化了客户端与复杂子体系之间的交互。
表面模式的核心头脑是：通过为复杂的子体系提供一个简朴的接口，来低落客户端和子体系之间的耦合度，使得子体系对客户端透明。
2. 模式布局

表面模式主要包含以下几个核心角色：
     

• 表面(Facade)：为客户端提供一个统一的高层接口，封装了对子体系的访问，并且知道怎样将客户端的请求转发给适当的子体系对象
  
• 子体系(Subsystem)：实现了子体系的功能，并处置惩罚由表面临象分配的任务，但不需要知道表面的存在
  
• 客户端(Client)：通过表面接口访问子体系，而不是直接访问子体系中的对象
  

3. 表面模式与适配器模式的区别

固然表面模式和适配器模式都是包装模式（封装一些既有的类），但它们的意图和应用场景有明显的区别：
特性表面模式适配器模式主要意图为复杂子体系提供简朴接口使不兼容的接口可以或许一起工作接口改变创建新的便利接口转换已有接口以匹配客户端盼望包装对象包装多个干系对象通常包装单个对象复杂度简化复杂体系办理接口不匹配问题应用机遇子体系筹划之初或重构时利用已有组件但接口不匹配时 表面模式侧重于简化，而适配器模式侧重于兼容。表面模式通常在筹划之初就思量，而适配器模式则常用于办理已有体系的兼容问题。
4. C#代码示例

4.1 家庭影院体系

下面是一个利用表面模式简化家庭影院体系操作的例子：

1. using System;
3. // 子系统类 - 投影仪
4. public class Projector
5. {
6.     public void TurnOn()
7.     {
8.         Console.WriteLine("投影仪打开");
9.     }
10.    
11.     public void TurnOff()
12.     {
13.         Console.WriteLine("投影仪关闭");
14.     }
15.    
16.     public void SetInput(string input)
17.     {
18.         Console.WriteLine($"投影仪输入源设置为: {input}");
19.     }
20. }
22. // 子系统类 - 音响系统
23. public class SoundSystem
24. {
25.     public void TurnOn()
26.     {
27.         Console.WriteLine("音响系统打开");
28.     }
29.    
30.     public void TurnOff()
31.     {
32.         Console.WriteLine("音响系统关闭");
33.     }
34.    
35.     public void SetVolume(int level)
36.     {
37.         Console.WriteLine($"音响音量设置为: {level}");
38.     }
39.    
40.     public void SetSurroundSound()
41.     {
42.         Console.WriteLine("音响设置为环绕声模式");
43.     }
44. }
46. // 子系统类 - 播放器
47. public class StreamingPlayer
48. {
49.     public void TurnOn()
50.     {
51.         Console.WriteLine("播放器打开");
52.     }
53.    
54.     public void TurnOff()
55.     {
56.         Console.WriteLine("播放器关闭");
57.     }
58.    
59.     public void Play(string movie)
60.     {
61.         Console.WriteLine($"播放器开始播放: {movie}");
62.     }
63.    
64.     public void Stop()
65.     {
66.         Console.WriteLine("播放器停止播放");
67.     }
68. }
70. // 子系统类 - 灯光
71. public class Lights
72. {
73.     public void TurnOn()
74.     {
75.         Console.WriteLine("灯光打开");
76.     }
77.    
78.     public void TurnOff()
79.     {
80.         Console.WriteLine("灯光关闭");
81.     }
82.    
83.     public void Dim(int level)
84.     {
85.         Console.WriteLine($"灯光调暗至: {level}%");
86.     }
87. }
89. // 子系统类 - 自动窗帘
90. public class Curtains
91. {
92.     public void Open()
93.     {
94.         Console.WriteLine("窗帘打开");
95.     }
96.    
97.     public void Close()
98.     {
99.         Console.WriteLine("窗帘关闭");
100.     }
101. }
103. // 外观类 - 家庭影院外观
104. public class HomeTheaterFacade
105. {
106.     // 引用子系统组件
107.     private Projector projector;
108.     private SoundSystem soundSystem;
109.     private StreamingPlayer player;
110.     private Lights lights;
111.     private Curtains curtains;
112.    
113.     // 构造函数，注入所有子系统组件
114.     public HomeTheaterFacade(Projector projector, SoundSystem soundSystem,
115.                             StreamingPlayer player, Lights lights, Curtains curtains)
116.     {
117.         this.projector = projector;
118.         this.soundSystem = soundSystem;
119.         this.player = player;
120.         this.lights = lights;
121.         this.curtains = curtains;
122.     }
123.    
124.     // 外观方法 - 观看电影
125.     // 这个方法封装了观看电影所需的一系列复杂操作
126.     public void WatchMovie(string movie)
127.     {
128.         Console.WriteLine("\n=== 准备观看电影 ===");
129.         
130.         // 按照特定顺序调用各个子系统
131.         curtains.Close();         // 关闭窗帘
132.         lights.Dim(10);           // 将灯光调暗至10%
133.         projector.TurnOn();       // 打开投影仪
134.         projector.SetInput("HDMI");// 设置投影仪输入源
135.         soundSystem.TurnOn();     // 打开音响系统
136.         soundSystem.SetSurroundSound(); // 设置环绕声
137.         soundSystem.SetVolume(5); // 设置适当音量
138.         player.TurnOn();          // 打开播放器
139.         player.Play(movie);       // 播放指定电影
140.         
141.         Console.WriteLine($"=== 现在播放: {movie} ===");
142.     }
143.    
144.     // 外观方法 - 结束电影
145.     // 这个方法封装了结束电影时的一系列操作
146.     public void EndMovie()
147.     {
148.         Console.WriteLine("\n=== 结束电影 ===");
149.         
150.         // 按照特定顺序调用各个子系统
151.         player.Stop();            // 停止播放
152.         player.TurnOff();         // 关闭播放器
153.         soundSystem.TurnOff();    // 关闭音响系统
154.         projector.TurnOff();      // 关闭投影仪
155.         lights.TurnOn();          // 打开灯光
156.         curtains.Open();          // 打开窗帘
157.         
158.         Console.WriteLine("=== 影院系统已关闭 ===");
159.     }
160. }
162. // 客户端代码
163. public class Client
164. {
165.     public static void Main(string[] args)
166.     {
167.         // 创建子系统对象
168.         Projector projector = new Projector();
169.         SoundSystem soundSystem = new SoundSystem();
170.         StreamingPlayer player = new StreamingPlayer();
171.         Lights lights = new Lights();
172.         Curtains curtains = new Curtains();
173.         
174.         // 创建外观对象
175.         HomeTheaterFacade homeTheater =
176.             new HomeTheaterFacade(projector, soundSystem, player, lights, curtains);
177.         
178.         // 使用外观简化的接口观看电影
179.         homeTheater.WatchMovie("星际穿越");
180.         
181.         Console.WriteLine("\n...[电影播放中]...\n");
182.         
183.         // 使用外观简化的接口结束电影
184.         homeTheater.EndMovie();
185.         
186.         // 对比：如果没有外观模式，客户端代码会变成这样
187.         Console.WriteLine("\n=== 不使用外观模式时的客户端代码 ===");
188.         Console.WriteLine("curtains.Close();");
189.         Console.WriteLine("lights.Dim(10);");
190.         Console.WriteLine("projector.TurnOn();");
191.         Console.WriteLine("projector.SetInput("HDMI");");
192.         Console.WriteLine("soundSystem.TurnOn();");
193.         Console.WriteLine("soundSystem.SetSurroundSound();");
194.         Console.WriteLine("soundSystem.SetVolume(5);");
195.         Console.WriteLine("player.TurnOn();");
196.         Console.WriteLine("player.Play("星际穿越");");
197.         // ...以及更多代码...
198.     }
199. }

复制代码

4.2 复杂计算机体系启动示例

下面是另一个利用表面模式简化计算机体系启动过程的例子：

1. using System;
3. // 子系统类 - CPU
4. public class CPU
5. {
6.     public void Freeze()
7.     {
8.         Console.WriteLine("CPU: 冻结所有CPU运行");
9.     }
10.    
11.     public void Jump(long position)
12.     {
13.         Console.WriteLine($"CPU: 跳转到内存地址 {position}");
14.     }
15.    
16.     public void Execute()
17.     {
18.         Console.WriteLine("CPU: 开始执行指令");
19.     }
20. }
22. // 子系统类 - 内存
23. public class Memory
24. {
25.     public void Load(long position, string data)
26.     {
27.         Console.WriteLine($"内存: 载入数据到地址 {position} -> 数据: {data}");
28.     }
29. }
31. // 子系统类 - 硬盘
32. public class HardDrive
33. {
34.     public string Read(long lba, int size)
35.     {
36.         Console.WriteLine($"硬盘: 从扇区 {lba} 读取 {size} 字节");
37.         return "操作系统数据...";
38.     }
39. }
41. // 外观类 - 计算机
42. public class ComputerFacade
43. {
44.     // 引用子系统组件
45.     private CPU cpu;
46.     private Memory memory;
47.     private HardDrive hardDrive;
48.    
49.     // 构造函数
50.     public ComputerFacade()
51.     {
52.         // 创建子系统组件实例
53.         this.cpu = new CPU();
54.         this.memory = new Memory();
55.         this.hardDrive = new HardDrive();
56.     }
57.    
58.     // 外观方法 - 启动计算机
59.     public void Start()
60.     {
61.         Console.WriteLine("=== 计算机启动过程开始 ===");
62.         
63.         // 按照启动计算机的特定步骤调用子系统
64.         cpu.Freeze(); // 冻结CPU
65.         
66.         // 从硬盘读取引导程序
67.         string bootData = hardDrive.Read(0, 512);
68.         
69.         // 将引导程序载入内存
70.         memory.Load(0, bootData);
71.         
72.         // CPU跳转到引导程序位置
73.         cpu.Jump(0);
74.         
75.         // 开始执行引导程序
76.         cpu.Execute();
77.         
78.         Console.WriteLine("=== 计算机启动完成 ===");
79.     }
80. }
82. // 客户端代码
83. public class ComputerClient
84. {
85.     public static void Main(string[] args)
86.     {
87.         // 创建并使用计算机外观
88.         ComputerFacade computer = new ComputerFacade();
89.         computer.Start();
90.         
91.         // 如果没有外观模式，客户端代码会更复杂
92.         Console.WriteLine("\n=== 不使用外观模式的客户端代码 ===");
93.         Console.WriteLine("CPU cpu = new CPU();");
94.         Console.WriteLine("Memory memory = new Memory();");
95.         Console.WriteLine("HardDrive hardDrive = new HardDrive();");
96.         Console.WriteLine("cpu.Freeze();");
97.         Console.WriteLine("String bootData = hardDrive.Read(0, 512);");
98.         Console.WriteLine("memory.Load(0, bootData);");
99.         Console.WriteLine("cpu.Jump(0);");
100.         Console.WriteLine("cpu.Execute();");
101.     }
102. }

复制代码

5. 表面模式的实现方式

实现表面模式通常依照以下步骤：

• 辨认子体系组件：确定需要简化的复杂子体系，以及子体系中需要暴露给客户端的功能
  
• 筹划表面接口：筹划一个高层接口，提供客户端需要的简化功能
  
• 实现表面类：创建表面类，组合所需的子体系组件，并在表面方法中和谐它们的工作
  
• 客户端利用表面：客户端通过表面类访问子体系功能，而不是直接与各个子体系组件交互
  

实现表面模式的几种变体：

5.1 简朴表面

最基本的情势，表面类直接创建和管理子体系组件。

1. public class SimpleFacade
2. {
3.     private SubsystemA subsystemA;
4.     private SubsystemB subsystemB;
5.    
6.     public SimpleFacade()
7.     {
8.         this.subsystemA = new SubsystemA();
9.         this.subsystemB = new SubsystemB();
10.     }
11.    
12.     public void Operation()
13.     {
14.         subsystemA.OperationA();
15.         subsystemB.OperationB();
16.     }
17. }

复制代码

5.2 依赖注入表面

通过构造函数注入子体系组件，进步可测试性和灵活性。

1. public class DIFacade
2. {
3.     private ISubsystemA subsystemA;
4.     private ISubsystemB subsystemB;
5.    
6.     public DIFacade(ISubsystemA subsystemA, ISubsystemB subsystemB)
7.     {
8.         this.subsystemA = subsystemA;
9.         this.subsystemB = subsystemB;
10.     }
11.    
12.     public void Operation()
13.     {
14.         subsystemA.OperationA();
15.         subsystemB.OperationB();
16.     }
17. }

复制代码

5.3 单例表面

确保整个体系只有一个表面实例。

1. public class SingletonFacade
2. {
3.     private static SingletonFacade instance;
4.     private SubsystemA subsystemA;
5.     private SubsystemB subsystemB;
6.    
7.     private SingletonFacade()
8.     {
9.         this.subsystemA = new SubsystemA();
10.         this.subsystemB = new SubsystemB();
11.     }
12.    
13.     public static SingletonFacade Instance
14.     {
15.         get
16.         {
17.             if (instance == null)
18.             {
19.                 instance = new SingletonFacade();
20.             }
21.             return instance;
22.         }
23.     }
24.    
25.     public void Operation()
26.     {
27.         subsystemA.OperationA();
28.         subsystemB.OperationB();
29.     }
30. }

复制代码

6. 表面模式的应用场景

表面模式适用于以下场景：
6.1 复杂子体系的简化接口

当你需要为复杂的子体系提供一个简朴的接口时，表面模式非常有效。比方，上面的家庭影院和计算机启动示例。
6.2 分层筹划

在分层架构中，每一层都可以利用表面模式来提供对下一层的简化访问。比方，在典型的三层架构（表现层、业务逻辑层、数据访问层）中，每一层可以为其上层提供一个表面。

1. // 数据访问层外观
2. public class DataAccessFacade
3. {
4.     private UserRepository userRepo;
5.     private OrderRepository orderRepo;
6.     private ProductRepository productRepo;
7.    
8.     public DataAccessFacade()
9.     {
10.         userRepo = new UserRepository();
11.         orderRepo = new OrderRepository();
12.         productRepo = new ProductRepository();
13.     }
14.    
15.     // 提供给业务逻辑层的简化方法
16.     public User GetUser(int userId) { return userRepo.GetById(userId); }
17.     public Order GetOrder(int orderId) { return orderRepo.GetById(orderId); }
18.     public List<Product> GetUserPurchasedProducts(int userId)
19.     {
20.         List<Product> products = new List<Product>();
21.         List<Order> orders = orderRepo.GetByUserId(userId);
22.         
23.         foreach (Order order in orders)
24.         {
25.             foreach (int productId in order.ProductIds)
26.             {
27.                 products.Add(productRepo.GetById(productId));
28.             }
29.         }
30.         
31.         return products;
32.     }
33. }
35. // 业务逻辑层外观
36. public class BusinessLogicFacade
37. {
38.     private DataAccessFacade dataAccess;
39.     private DiscountCalculator discountCalculator;
40.     private TaxCalculator taxCalculator;
41.    
42.     public BusinessLogicFacade()
43.     {
44.         dataAccess = new DataAccessFacade();
45.         discountCalculator = new DiscountCalculator();
46.         taxCalculator = new TaxCalculator();
47.     }
48.    
49.     // 提供给表示层的简化方法
50.     public decimal CalculateOrderTotal(int orderId)
51.     {
52.         Order order = dataAccess.GetOrder(orderId);
53.         decimal subtotal = order.Subtotal;
54.         decimal discount = discountCalculator.CalculateDiscount(order);
55.         decimal tax = taxCalculator.CalculateTax(subtotal - discount);
56.         
57.         return subtotal - discount + tax;
58.     }
59. }

复制代码

6.3 第三方库的封装

利用表面模式封装复杂的第三方库或API，可以简化调用并隔离体系与外部依赖的变化。

1. // 第三方支付库的外观
2. public class PaymentFacade
3. {
4.     private ThirdPartyPaymentProcessor processor;
5.     private PaymentValidator validator;
6.     private TransactionLogger logger;
7.    
8.     public PaymentFacade()
9.     {
10.         processor = new ThirdPartyPaymentProcessor();
11.         validator = new PaymentValidator();
12.         logger = new TransactionLogger();
13.     }
14.    
15.     // 简化的支付方法
16.     public bool ProcessPayment(string cardNumber, decimal amount)
17.     {
18.         // 验证支付信息
19.         if (!validator.ValidateCard(cardNumber))
20.         {
21.             return false;
22.         }
23.         
24.         // 记录交易开始
25.         string transactionId = logger.LogTransactionStart(cardNumber, amount);
26.         
27.         try
28.         {
29.             // 调用第三方处理器
30.             bool result = processor.Authorize(cardNumber, amount);
31.             if (result)
32.             {
33.                 result = processor.Capture(cardNumber, amount);
34.             }
35.             
36.             // 记录交易结果
37.             logger.LogTransactionResult(transactionId, result);
38.             
39.             return result;
40.         }
41.         catch (Exception ex)
42.         {
43.             // 记录错误
44.             logger.LogError(transactionId, ex.Message);
45.             return false;
46.         }
47.     }
48. }

复制代码

6.4 遗留体系的现代接口

表面模式可以为老旧、复杂的体系提供一个更现代、更简便的接口。

1. // 遗留系统的外观
2. public class LegacySystemFacade
3. {
4.     private LegacyDatabase database;
5.     private LegacyAuthenticator authenticator;
6.     private LegacyFileSystem fileSystem;
7.    
8.     public LegacySystemFacade()
9.     {
10.         database = new LegacyDatabase();
11.         authenticator = new LegacyAuthenticator();
12.         fileSystem = new LegacyFileSystem();
13.     }
14.    
15.     // 现代化的用户认证方法
16.     public bool Authenticate(string username, string password)
17.     {
18.         // 旧系统需要先连接数据库
19.         database.Connect("localhost", "admin", "password");
20.         
21.         // 查询用户记录
22.         string userRecord = database.ExecuteQuery("SELECT * FROM USERS WHERE USERNAME = '" + username + "'");
23.         
24.         // 认证用户
25.         return authenticator.CheckCredentials(userRecord, password);
26.     }
27.    
28.     // 现代化的文件处理方法
29.     public string GetDocument(string documentId)
30.     {
31.         // 建立文件系统连接
32.         fileSystem.ConnectToServer();
33.         
34.         // 旧系统复杂的文件读取逻辑
35.         string filePath = fileSystem.TranslateDocumentIdToPath(documentId);
36.         byte[] fileContents = fileSystem.ReadFileBytes(filePath);
37.         string documentText = System.Text.Encoding.UTF8.GetString(fileContents);
38.         
39.         // 断开连接
40.         fileSystem.DisconnectFromServer();
41.         
42.         return documentText;
43.     }
44. }

复制代码

7. 表面模式的优缺点

7.1 优点

• 隔离客户端与子体系：客户端不需要了解复杂子体系的内部工作原理。
  
• 疏松耦合：淘汰客户端代码和子体系之间的依赖关系。
  
• 简化客户端代码：客户端利用简朴的表面接口，而不是直接处置惩罚多个子体系组件。
  
• 分层筹划支持：可以为每一层提供统一的入口点，使架构更加清晰。
  
• 封装变化：当子体系变化时，只需修改表面类，而不影响客户端代码。
  

7.2 缺点

• 可能引入巨大的表面类：如果表面类承担过多责任，可能会变得过于巨大和复杂。
  
• 有时会低落灵活性：可能会限定对子体系的精致控制，因为表面只提供了有限的接口。
  
• 可能违反开闭原则：当需要添加新的子体系功能时，可能需要修改表面类。
  
• 可能产生多余的间接调用：如果客户端只需利用子体系的一小部分功能，通过表面可能会引入不必要的性能开销。
  

8. 表面模式与其他筹划模式的关系

筹划模式关系形貌适配器模式适配器将一个类的接口转换为客户端盼望的另一个接口，而表面提供了一个简化的接口。适配器办理接口不匹配问题，表面办理复杂性问题。中介者模式两者都旨在处置惩罚多个类之间的关系，但表面简化了客户端与子体系之间的交互，而中介者会合管理同事对象之间的交互。署理模式署理控制对对象的访问，而表面简化对子体系的访问。署理通常只包装一个对象，而表面可能包装多个子体系组件。单例模式表面类通常利用单例模式实现，确保体系中只有一个表面实例。 9. 现实项目中的表面模式应用

9.1 Web API的服务层

在Web API开发中，服务层可以作为控制器和仓储层之间的表面：

1. // 仓储层
2. public interface IUserRepository
3. {
4.     User GetById(int id);
5.     void Save(User user);
6. }
8. public interface IOrderRepository
9. {
10.     Order GetById(int id);
11.     List<Order> GetByUserId(int userId);
12.     void Save(Order order);
13. }
15. // 服务层（外观）
16. public class UserService
17. {
18.     private readonly IUserRepository userRepository;
19.     private readonly IOrderRepository orderRepository;
20.     private readonly IEmailService emailService;
21.     private readonly IAuthenticationService authService;
22.    
23.     public UserService(
24.         IUserRepository userRepository,
25.         IOrderRepository orderRepository,
26.         IEmailService emailService,
27.         IAuthenticationService authService)
28.     {
29.         this.userRepository = userRepository;
30.         this.orderRepository = orderRepository;
31.         this.emailService = emailService;
32.         this.authService = authService;
33.     }
34.    
35.     // 简化的用户注册流程
36.     public bool RegisterUser(string username, string email, string password)
37.     {
38.         // 检查用户名是否已存在
39.         if (authService.IsUsernameTaken(username))
40.             return false;
41.         
42.         // 创建用户账户
43.         var user = new User { Username = username, Email = email };
44.         authService.SetPassword(user, password);
45.         
46.         // 保存用户
47.         userRepository.Save(user);
48.         
49.         // 发送欢迎邮件
50.         emailService.SendWelcomeEmail(email, username);
51.         
52.         return true;
53.     }
54.    
55.     // 简化的订单历史查询
56.     public List<OrderSummary> GetUserOrderHistory(int userId)
57.     {
58.         User user = userRepository.GetById(userId);
59.         if (user == null)
60.             return new List<OrderSummary>();
61.             
62.         List<Order> orders = orderRepository.GetByUserId(userId);
63.         
64.         // 转换为展示模型
65.         return orders.Select(o => new OrderSummary
66.         {
67.             Id = o.Id,
68.             Date = o.Date,
69.             Amount = o.TotalAmount,
70.             Status = o.Status
71.         }).ToList();
72.     }
73. }
75. // API控制器
76. public class UserController : ApiController
77. {
78.     private readonly UserService userService;
79.    
80.     public UserController(UserService userService)
81.     {
82.         this.userService = userService;
83.     }
84.    
85.     [HttpPost]
86.     public IActionResult Register([FromBody] RegisterModel model)
87.     {
88.         // 控制器只需调用外观的简单方法
89.         bool success = userService.RegisterUser(
90.             model.Username, model.Email, model.Password);
91.             
92.         if (success)
93.             return Ok();
94.         else
95.             return BadRequest("用户名已存在");
96.     }
97.    
98.     [HttpGet("{userId}/orders")]
99.     public IActionResult GetOrders(int userId)
100.     {
101.         // 控制器通过外观获取订单历史
102.         var orders = userService.GetUserOrderHistory(userId);
103.         return Ok(orders);
104.     }
105. }

复制代码

9.2 跨平台应用步伐

表面模式可用于隔离平台特定的API，提供一个统一的跨平台接口：

1. // 平台特定的文件系统实现
2. public interface IFileSystem
3. {
4.     bool FileExists(string path);
5.     string ReadAllText(string path);
6.     void WriteAllText(string path, string contents);
7. }
9. // Windows实现
10. public class WindowsFileSystem : IFileSystem
11. {
12.     public bool FileExists(string path)
13.     {
14.         return System.IO.File.Exists(path);
15.     }
16.    
17.     public string ReadAllText(string path)
18.     {
19.         return System.IO.File.ReadAllText(path);
20.     }
21.    
22.     public void WriteAllText(string path, string contents)
23.     {
24.         System.IO.File.WriteAllText(path, contents);
25.     }
26. }
28. // Android实现
29. public class AndroidFileSystem : IFileSystem
30. {
31.     private Context context;
32.    
33.     public AndroidFileSystem(Context context)
34.     {
35.         this.context = context;
36.     }
37.    
38.     public bool FileExists(string filename)
39.     {
40.         try {
41.             context.OpenFileInput(filename);
42.             return true;
43.         } catch (Exception) {
44.             return false;
45.         }
46.     }
47.    
48.     public string ReadAllText(string filename)
49.     {
50.         using (var inputStream = context.OpenFileInput(filename))
51.         using (var reader = new BufferedReader(new InputStreamReader(inputStream)))
52.         {
53.             StringBuilder content = new StringBuilder();
54.             string line;
55.             while ((line = reader.ReadLine()) != null)
56.             {
57.                 content.AppendLine(line);
58.             }
59.             return content.ToString();
60.         }
61.     }
62.    
63.     public void WriteAllText(string filename, string contents)
64.     {
65.         using (var outputStream = context.OpenFileOutput(filename, FileMode.Private))
66.         using (var writer = new PrintWriter(outputStream))
67.         {
68.             writer.Write(contents);
69.         }
70.     }
71. }
73. // 外观类
74. public class StorageService
75. {
76.     private readonly IFileSystem fileSystem;
77.    
78.     public StorageService(IFileSystem fileSystem)
79.     {
80.         this.fileSystem = fileSystem;
81.     }
82.    
83.     // 高层方法：保存用户设置
84.     public bool SaveSettings(Dictionary<string, string> settings)
85.     {
86.         try
87.         {
88.             // 序列化设置
89.             string json = JsonSerializer.Serialize(settings);
90.             
91.             // 保存到文件
92.             fileSystem.WriteAllText("settings.json", json);
93.             return true;
94.         }
95.         catch (Exception)
96.         {
97.             return false;
98.         }
99.     }
100.    
101.     // 高层方法：加载用户设置
102.     public Dictionary<string, string> LoadSettings()
103.     {
104.         try
105.         {
106.             // 检查文件是否存在
107.             if (!fileSystem.FileExists("settings.json"))
108.                 return new Dictionary<string, string>();
109.                
110.             // 读取并反序列化
111.             string json = fileSystem.ReadAllText("settings.json");
112.             return JsonSerializer.Deserialize<Dictionary<string, string>>(json);
113.         }
114.         catch (Exception)
115.         {
116.             return new Dictionary<string, string>();
117.         }
118.     }
119. }
121. // 客户端代码
122. public class SettingsScreen
123. {
124.     private StorageService storageService;
125.    
126.     public SettingsScreen(StorageService storageService)
127.     {
128.         this.storageService = storageService;
129.     }
130.    
131.     public void SaveUserPreferences(string theme, string language)
132.     {
133.         var settings = new Dictionary<string, string>
134.         {
135.             ["theme"] = theme,
136.             ["language"] = language
137.         };
138.         
139.         // 使用外观简化存储操作
140.         if (storageService.SaveSettings(settings))
141.             Console.WriteLine("设置已保存");
142.         else
143.             Console.WriteLine("保存设置失败");
144.     }
145.    
146.     public void LoadUserPreferences()
147.     {
148.         // 使用外观简化加载操作
149.         var settings = storageService.LoadSettings();
150.         
151.         string theme = settings.ContainsKey("theme") ? settings["theme"] : "default";
152.         string language = settings.ContainsKey("language") ? settings["language"] : "en";
153.         
154.         Console.WriteLine($"加载设置: 主题={theme}, 语言={language}");
155.     }
156. }

复制代码

10. 表面模式的最佳实践

• 保持表面简朴：表面类应该提供一个简朴、统一的接口，避免引入太多复杂性。
  
• 不要强制利用表面：表面应该是可选的，客户端应该可以根据需要直接访问子体系组件。
  
• 适当分解大型表面：如果一个表面变得过于巨大，思量将其分解为多个干系的表面类。
  
• 利用依赖注入：通过构造函数注入子体系组件，而不是在表面内部直接创建它们，这进步了代码的可测试性和灵活性。
  
• 思量接口而不是详细类：表面应该依赖于抽象接口而不是详细实现，这样可以更容易地更换子体系组件。
  
• 不要过度利用：并非所有子体系都需要表面。当子体系充足简朴时，直接利用可能更清晰。
  

11. 总结

表面模式是一种强大的布局型筹划模式，它通过为复杂子体系提供一个简化的高层接口，使客户端代码更加简便和易于利用。表面模式不仅可以低落体系的复杂度，还可以淘汰客户端和子体系之间的耦合，进步代码的可维护性和灵活性。
表面模式的核心上风在于：

• 简化了客户端对复杂子体系的利用
  
• 促进了松耦合的体系筹划
  
• 有助于分层架构的实现
  
• 提供了隔离变化的机制
  

在现实开发中，表面模式常用于体系分层、API筹划、遗留体系集成和跨平台开发等场景。它与其他筹划模式（如适配器、中介者、署理等）有明显的区别，并且通常与这些模式配合利用，以构建更加灵活和可维护的软件体系。
当我们面临复杂子体系，或者希望为客户端提供一个统一、简便的接口时，应该思量利用表面模式。但同时也要注意避免过度利用，以免引入不必要的抽象层。
学习资源

• Design Patterns: Elements of Reusable Object-Oriented Software - GoF经典著作
  
• Head First Design Patterns - 生动易懂的筹划模式入门册本
  
• Refactoring.Guru - Facade Pattern
  
• C# Design Pattern Essentials
  
• Microsoft Learn - Design Patterns