.NET-9-计算机思想-构建器模式(Builder Pattern)
目录[*]前言
[*]学习参考
[*]过程
[*]总结:
前言
做个自由仔。
学习参考
[*]ChatGpt;
[*]https://www.cnblogs.com/zhili/p/DesignPatternSummery.html(大佬的，看了好多次)
过程
[*]原由：
一开始只是想查查链式调用原理，以为是要继承什么接口,实现什么方法才可以实现；像可以实现foreach;一查好简单；哎~，是平时思考少了；成代码机器了，我冒昧了。
public class Person
{
private string _name;
private int _age;
public Person SetName(string name)
{
_name = name;
return this; // 返回当前对象以支持链式调用
}
public Person SetAge(int age)
{
_age = age;
return this; // 返回当前对象以支持链式调用
}
public void Display()
{
Console.WriteLine($"Name: {_name}, Age: {_age}");
}
}
//调用：
Person person = new Person();
// 链式调用示例
person.SetName("John")
.SetAge(30)
.Display();
[*]然后我就看到了构建器模式；又一次理解了一次（抱歉以前的忘了；）
然后又问了问优点，适用场景；
优点：
- 可读性高: 构建器模式使代码更加易读，特别是在创建复杂对象时。
- 灵活性: 可以很容易地添加或删除属性，而不需要更改客户端代码。
- 不可变对象: 通过构建器模式可以创建不可变对象（所有属性在对象创建后都不能更改），提高了代码的可靠性。
适用场景：
- 需要创建的对象具有很多可选参数时。
- 对象的构建过程复杂时，例如需要分步骤进行初始化。
- 需要确保对象在创建时是有效的，并且不希望对象在创建后改变。
说实话，一开始我是没理解这个灵活性的，因为我想到了直接传递一个参数实体；
那岂不更方便，结果后面给我说常常是两者结合，来构建复杂的对象；好吧；
还有那个可读性；这样，我的对象初始化也可以呀（new person{}）
public class Person
{
private string _name;
private int _age;
private string _address;
private Person() { }
public class Builder
{
private Person _person = new Person();
public Builder SetName(string name)
{
_person._name = name;
return this;
}
public Builder SetAge(int age)
{
_person._age = age;
return this;
}
public Builder SetAddress(string address)
{
_person._address = address;
return this;
}
public Person Build()
{
// 可以在这里添加对象验证逻辑
// 如：if (string.IsNullOrEmpty(_person._name))
// throw new InvalidOperationException("Make cannot be null or empty");
return _person;
}
}
}
//调用：
Person person = new Person.Builder()
.SetName("John")
.SetAge(30)
.SetAddress("123 Main St")
.Build();
Console.WriteLine($"Name: {person._name}, Age: {person._age}, Address: {person._address}");
// 输出: Name: John, Age: 30, Address: 123 Main St
-------------------------------------------------------------------
//使用参数对象
public class PersonParameters
{
public string Name { get; set; }
public int Age { get; set; }
public string Address { get; set; }
}
public class Person
{
private string _name;
private int _age;
private string _address;
private Person() { }
public class Builder
{
private PersonParameters _parameters = new PersonParameters();
public Builder SetName(string name)
{
_parameters.Name = name;
return this;
}
public Builder SetAge(int age)
{
_parameters.Age = age;
return this;
}
public Builder SetAddress(string address)
{
_parameters.Address = address;
return this;
}
public Person Build()
{
//构造对象初始化
Person _person=new Person
{
Name=_parameters.Name,
Age=_parameters.Age,
Name=_parameters.Name,
}
return _person;
}
}
}
[*]后面我就想到了Serilog;那个初始化好像就是链式的；构建器模式耶；（主机构建哪里都是，抱歉了）
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Console()
.WriteTo.File("logs/log.txt", rollingInterval: RollingInterval.Day)
.CreateLogger();
[*]接着我继续问：.MinimumLevel.Debug() 这里的MinimumLevel是一个类；而Debug()是一个静态方法么；
我是想的MinimumLevel静态类，Debug()是一个静态方法；
好吧我的想法是错的；是中间加了一个类来设置一些信息；或者中间类的扩展方法来的
public class LoggerConfiguration
{
public LoggerMinimumLevelConfiguration MinimumLevel { get; }
public LoggerSinkConfiguration WriteTo { get; }
// 其他配置方法和属性...
public LoggerConfiguration()
{
MinimumLevel = new LoggerMinimumLevelConfiguration(this);
WriteTo = new LoggerSinkConfiguration(this);
}
}
public class LoggerMinimumLevelConfiguration
{
private readonly LoggerConfiguration _loggerConfiguration;
public LoggerMinimumLevelConfiguration(LoggerConfiguration loggerConfiguration)
{
_loggerConfiguration = loggerConfiguration;
}
public LoggerConfiguration Debug()
{
_loggerConfiguration.MinimumLevelControlledBy(new LoggingLevelSwitch(LogEventLevel.Debug));
return _loggerConfiguration;
}
// 其他级别设置方法...
}
----------
//，WriteTo.Console()
//使用扩展方法
public static class LoggerSinkConfigurationExtensions
{
public static LoggerConfiguration Console(this LoggerSinkConfiguration sinkConfiguration)
{
//打印
return sinkConfiguration.Sink(new ConsoleSink());
}
// 其他扩展方法...
}
//使用中间类
public class LoggerSinkConfiguration
{
private readonly LoggerConfiguration _loggerConfiguration;
public LoggerSinkConfiguration(LoggerConfiguration loggerConfiguration)
{
_loggerConfiguration = loggerConfiguration;
}
public LoggerConfiguration Console()
{
// 配置控制台输出
return _loggerConfiguration;
}
public LoggerConfiguration File(string path, RollingInterval rollingInterval)
{
// 配置文件输出及滚动策略
return _loggerConfiguration;
}
// 其他输出目标配置方法...
}
[*]然后我又看了一下，回顾了我收藏的资源，果然我适合当咸鱼。
总结:
主要了为了记忆深刻一些；感觉有了那些大模型后更加懒了，不仅不主动去了解一些知识，也觉得以前写都没多大意义；留着留个念想；
觉得反正ai一下么，不手到擒来（想法是错的，使人懒惰，技术很难精进的）；但是如果当个小喽喽，实话说无所谓了，我们很自信，我们也要掂量掂量自己的分量。
当然我也希望可以直接大跃进到，脑机接口民用，直接动脑子搜索（在思维上），直接读取相关数据就好了，也不能都记住，毕竟内存还是有限的，脑容量是硬盘，记忆是内存。
来源:https://www.cnblogs.com/zhouyitty/p/18259772
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！
页:
[1]