.NET-9-计算机思想-构建器模式(Builder Pattern)

目次

• 前言
  
• 学习参考
  
• 过程
  
• 总结:
  

前言

做个自由仔。
学习参考

• ChatGpt;
  
• https://www.cnblogs.com/zhili/p/DesignPatternSummery.html(大佬的，看了好多次)
  

过程

• 原由：
  一开始只是想查查链式调用原理，以为是要继承什么接口,实现什么方法才可以实现；像可以实现foreach;一查好简单；哎~，是平常思考少了；成代码机器了，我冒昧了。
  

1. public class Person
2. {
3.     private string _name;
4.     private int _age;
5.     public Person SetName(string name)
6.     {
7.         _name = name;
8.         return this; // 返回当前对象以支持链式调用
9.     }
10.     public Person SetAge(int age)
11.     {
12.         _age = age;
13.         return this; // 返回当前对象以支持链式调用
14.     }
15.     public void Display()
16.     {
17.         Console.WriteLine($"Name: {_name}, Age: {_age}");
18.     }
19. }
20. //调用：
21. Person person = new Person();        
22. // 链式调用示例
23. person.SetName("John")
24.         .SetAge(30)
25.         .Display();

复制代码

• 然后我就看到了构建器模式；又一次明白了一次（歉仄从前的忘了；）
  然后又问了问优点，实用场景；
  

1. 优点：
2. - 可读性高: 构建器模式使代码更加易读，特别是在创建复杂对象时。
3. - 灵活性: 可以很容易地添加或删除属性，而不需要更改客户端代码。
4. - 不可变对象: 通过构建器模式可以创建不可变对象（所有属性在对象创建后都不能更改），提高了代码的可靠性。
5. 适用场景：
6. - 需要创建的对象具有很多可选参数时。
7. - 对象的构建过程复杂时，例如需要分步骤进行初始化。
8. - 需要确保对象在创建时是有效的，并且不希望对象在创建后改变。
9. 说实话，一开始我是没理解这个灵活性的，因为我想到了直接传递一个参数实体；
10. 那岂不更方便，结果后面给我说常常是两者结合，来构建复杂的对象；好吧；
11. 还有那个可读性；这样，我的对象初始化也可以呀（new person{}）
13. public class Person
14. {
15.     private string _name;
16.     private int _age;
17.     private string _address;
18.     private Person() { }
19.     public class Builder
20.     {
21.         private Person _person = new Person();
22.         public Builder SetName(string name)
23.         {
24.             _person._name = name;
25.             return this;
26.         }
27.         public Builder SetAge(int age)
28.         {
29.             _person._age = age;
30.             return this;
31.         }
32.         public Builder SetAddress(string address)
33.         {
34.             _person._address = address;
35.             return this;
36.         }
37.         public Person Build()
38.         {
39.             // 可以在这里添加对象验证逻辑
40.             // 如：if (string.IsNullOrEmpty(_person._name))  
41.             // throw new InvalidOperationException("Make cannot be null or empty");
42.             return _person;
43.         }
44.     }
45. }
46. //调用：
47. Person person = new Person.Builder()
48.                     .SetName("John")
49.                     .SetAge(30)
50.                     .SetAddress("123 Main St")
51.                     .Build();
52. Console.WriteLine($"Name: {person._name}, Age: {person._age}, Address: {person._address}");
53. // 输出: Name: John, Age: 30, Address: 123 Main St
55. -------------------------------------------------------------------
56. //使用参数对象
57. public class PersonParameters
58. {
59.     public string Name { get; set; }
60.     public int Age { get; set; }
61.     public string Address { get; set; }
62. }
63. public class Person
64. {
65.     private string _name;
66.     private int _age;
67.     private string _address;
68.     private Person() { }
69.     public class Builder
70.     {
71.         private PersonParameters _parameters = new PersonParameters();
72.         public Builder SetName(string name)
73.         {
74.             _parameters.Name = name;
75.             return this;
76.         }
77.         public Builder SetAge(int age)
78.         {
79.             _parameters.Age = age;
80.             return this;
81.         }
82.         public Builder SetAddress(string address)
83.         {
84.             _parameters.Address = address;
85.             return this;
86.         }
87.         public Person Build()
88.         {
89.             //构造对象初始化
90.             Person _person=new Person
91.             {
92.                 Name=_parameters.Name,
93.                 Age=_parameters.Age,
94.                 Name=_parameters.Name,
95.             }
96.             return _person;
97.         }
98.     }
99. }

复制代码

• 后面我就想到了Serilog;那个初始化好像就是链式的；构建器模式耶；（主机构建那里都是，歉仄了）
  

1. Log.Logger = new LoggerConfiguration()
2.             .MinimumLevel.Debug()
3.             .WriteTo.Console()
4.             .WriteTo.File("logs/log.txt", rollingInterval: RollingInterval.Day)
5.             .CreateLogger();

复制代码

• 接着我继承问：.MinimumLevel.Debug() 这里的MinimumLevel是一个类；而Debug()是一个静态方法么；
  我是想的MinimumLevel静态类，Debug()是一个静态方法；
  好吧我的想法是错的；是中心加了一个类来设置一些信息；大概中心类的扩展方法来的
  

1. public class LoggerConfiguration
2. {
3.     public LoggerMinimumLevelConfiguration MinimumLevel { get; }
4.     public LoggerSinkConfiguration WriteTo { get; }
5.     // 其他配置方法和属性...
6.     public LoggerConfiguration()
7.     {
8.         MinimumLevel = new LoggerMinimumLevelConfiguration(this);
9.         WriteTo = new LoggerSinkConfiguration(this);
10.     }
11. }
12. public class LoggerMinimumLevelConfiguration
13. {
14.     private readonly LoggerConfiguration _loggerConfiguration;
16.     public LoggerMinimumLevelConfiguration(LoggerConfiguration loggerConfiguration)
17.     {
18.         _loggerConfiguration = loggerConfiguration;
19.     }
20.     public LoggerConfiguration Debug()
21.     {
22.         _loggerConfiguration.MinimumLevelControlledBy(new LoggingLevelSwitch(LogEventLevel.Debug));
23.         return _loggerConfiguration;
24.     }
25.     // 其他级别设置方法...
26. }
28. ----------
29. //，WriteTo.Console()
30. //使用扩展方法
31. public static class LoggerSinkConfigurationExtensions
32. {
33.     public static LoggerConfiguration Console(this LoggerSinkConfiguration sinkConfiguration)
34.     {
35.         //打印
36.         return sinkConfiguration.Sink(new ConsoleSink());
37.     }
38.     // 其他扩展方法...
39. }
40. //使用中间类
41. public class LoggerSinkConfiguration
42. {
43.     private readonly LoggerConfiguration _loggerConfiguration;
44.     public LoggerSinkConfiguration(LoggerConfiguration loggerConfiguration)
45.     {
46.         _loggerConfiguration = loggerConfiguration;
47.     }
48.     public LoggerConfiguration Console()
49.     {
50.         // 配置控制台输出
51.         return _loggerConfiguration;
52.     }
53.     public LoggerConfiguration File(string path, RollingInterval rollingInterval)
54.     {
55.         // 配置文件输出及滚动策略
56.         return _loggerConfiguration;
57.     }
58.     // 其他输出目标配置方法...
59. }

复制代码

• 然后我又看了一下，回顾了我收藏的资源，果然我适合当咸鱼。
  

总结:

主要了为了记忆深刻一些；感觉有了那些大模型后更加懒了，不仅不主动去了解一些知识，也觉得从前写都没多大意义；留着留个念想；
觉得反正ai一下么，不手到擒来（想法是错的，使人懒惰，技术很难精进的）；但是如果当个小喽喽，真话说无所谓了，我们很自信，我们也要掂量掂量自己的分量。
当然我也希望可以直接大跃进到，脑机接口民用，直接动脑子搜刮（在思维上），直接读取相关数据就好了，也不能都记取，毕竟内存还是有限的，脑容量是硬盘，记忆是内存。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。