通过更新dll来更新软件，阐述解耦思想
解耦，就是把耦合起来的东西，解开来，不是少写东西
解耦是一种思想，在每个地方的实现都不一样。解在不同的地方。
解耦的一个主要目的：是为了分工，分工是为了高效。适用于大型软件，特别是需要多人合作的软件，必须掌握各种解耦技巧和方法
解耦：工作里，是主管经理，写的。工作实际中，懂这个业务人写的，相机，打开设备，关闭相机、设置曝光，软触发，硬触发。每个相机都这是这样的，只有比较深耕这个行业的人，他才能写好这个接口。
- 接口的解耦-可以把调用和实现进行解耦（分开），我需要相机有什么方法，我先在接口中定义，然后直接使用即可，将具体的实现交给别人再去实现
- 简单工厂的解耦-不直接依赖具体类，只依赖工厂和接口
- dll更新的解耦：不需要更新程序代码，就能更新软件。
C S h a r p 之简单工厂模式 CSharp之简单工厂模式 CSharp之简单工厂模式
当我们通过工厂方法完成对象创建的时候，我们的前端调用和后台实现完全解耦。
给一个新的dll,就可以实现无编译的更新
简单工厂就是个我们后续更多设计模式的学习，做的一个铺垫，和基础。
说简单实际一点：（1）解耦了实现和调用。允许未实现（先有个定义）就先调用。-上节课：讲的接口特性：允许实现类赋值给接口（2）切换相机不需要改代码，直接可以通过改配置文件实现。
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Data;
using System.Drawing;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace C_之简单工厂模式_使用App.config配置文件_
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
// 接口：可以把调用和实现进行解耦（分开），我需要相机有什么方法，我先在接口中定义，然后直接使用即可，将具体的实现交给别人再去实现
// 在现实中，我们可能直到相机可以拍照，但是不知道海康相机或者其他相机具体拍照是如何实现的，我们就可以先定义一个接口，继续往下写，把具体实现交给的专业人员。
// 接口特性：允许实现接口的类赋值给该接口
// 用海康的时候，new 海康
//ICamera Cam = new HikCamera();
//Cam.Start();
//Cam.Snap();
//Cam.Close();
// 用大华的时候就new 大华
//ICamera Cam = new DaHuaCamera();
//Cam.Start();
//Cam.Snap();
//Cam.Close();
// 调用过程，没说用的海康还是大华
ICamera camera = SimpleFactory.CamSDKCreator();
camera.Start();
camera.Snap();
camera.Close();
// 1.解耦，我写代码的时候，不要考虑实现（交给别人去写），真把程序允许起来的时候，程序是可以起来的，但是你的功能没有
// 2.切换相机时候，我们直接修改配置文件就可以，不用改代码了
}
}
/// <summary>
/// 简单工厂（根据配置文件，去生成对应的实例）
/// </summary>
public class SimpleFactory
{
// 不根据修改代码切换相机，根据app.config的配置文件进行相机的切换
public static string camType = ConfigurationManager.AppSettings["camType"].ToString();
public static ICamera CamSDKCreator()
{
if (camType== "HikCamSDK")
{
return new HikCamera();
}
else
{
return new DaHuaCamera();
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace C_之简单工厂模式_使用App.config配置文件_
{
public interface ICamera
{
bool Start();
bool Snap();
bool Close();
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace C_之简单工厂模式_使用App.config配置文件_
{
internal class HikCamera : ICamera
{
public bool Close()
{
MessageBox.Show("海康相机关闭");
return true;
}
public bool Snap()
{
MessageBox.Show("海康相机拍照");
return true;
}
public bool Start()
{
MessageBox.Show("海康相机打开");
return true;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace C_之简单工厂模式_使用App.config配置文件_
{
internal class DaHuaCamera : ICamera
{
public bool Close()
{
MessageBox.Show("大华相机关闭");
return true;
}
public bool Snap()
{
MessageBox.Show("大华相机关闭");
return true;
}
public bool Start()
{
MessageBox.Show("大华相机关闭");
return true;
}
}
}
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
</startup>
<appSettings>
<add key="camType" value="DaHuaCamSDK"/>
</appSettings>
</configuration>
简单工厂实习的基本步骤:
1.根据实际需求，封装变化（把要完成的任务，抽象为接口)
2.根据接口，编写不同的实现类。
一般的代码:经过分析，扩展性几乎没有。
按照OOP的基本原则–>开-闭原则(开放增加，封闭修改)
OOP告诉我们:写程序尽量体现"高内聚，低耦合"
低耦合:也就是对象或者一个模块，和另一个对象，或者另一个模块，他们之间不是直接依赖关系，比如对象使用，不是直接使用，而是通过工厂完成。也就是意味着对象的产生做了延迟。
常规设计（不用使用简单工厂类）
接口
/**
* 规定了要完成的主要任务
* **/
public interface ICamSDK
{
bool Start();
bool Close();
}
子类
public class BaslerCamSDK : ICamSDK
{
public bool Close()
{
// 实际开发中，放入具体的实现内容，其实这些都是要封装到类库中的，才是最后的商用
Console.WriteLine("Basler close");
return true;
}
public bool Start()
{
Console.WriteLine("Basler close");
return true;
}
}
子类
public class HikCamSDK : ICamSDK
{
public bool Close()
{
Console.WriteLine("HikCam close");
return true;
}
public bool Start()
{
Console.WriteLine("HikCam start");
return true;
}
}
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
</startup>
<appSettings>
<add key="camType" value="HikCamSDK"/>
</appSettings>
</configuration>
<appSettings>
<add key="camType" value="HikCamSDK"/>
</appSettings>
HikCamSDK需要和之前类的设计名字相同，因为就是调用它
简单工厂类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Configuration;
using 设计模式之简单工厂模式.CameraSDK;
namespace 设计模式之简单工厂模式
{
/**
* 简单工厂：构造单一对象的任务
* 提供一个对象创建的方法
* **/
class SimpleFactory
{
// 1. 根据用户的需求创建对象(这个需求，我们可以动态的配置到配置文件中)
private static string camType = ConfigurationManager.AppSettings["camType"].ToString();
// 2. 编写工厂方法
public static ICamSDK CamSDKCreator()
{
if (camType == "HikCamSDK")
{
return new HikCamSDK();
}
else if (camType == "BaslerCamSDK")
{
return new BaslerCamSDK();
}
else
{
// 默认
return null;
}
}
}
}
主程序调用
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using 设计模式之简单工厂模式.CameraSDK;
namespace 设计模式之简单工厂模式
{
class Program
{
static void Main(string[] args)
{
// 1. 通常做法，不使用简单工厂设计模式
// 经过分析，这样使用太繁琐，扩展性几乎没有，所以诞生了简单工厂模式
ICamSDK camSDK = new HikCamSDK();
camSDK.Start();
camSDK.Close();
Console.ReadLine();
/***
*
按照OOP的基本原则–>开-闭原则(开放增加，封闭修改)
OOP告诉我们:写程序尽量体现"高内聚，低耦合"
低耦合:也就是对象或者一个模块，和另一个对象，或者另一个模块，他们之间不是直接依赖关系，比如对象使用，不是直接使用，而是通过工厂完成。
也就是意味着对象的产生做了延迟。
*
* **/
// 2. 使用简单工厂设计模式（我前端就只需要调用SimpleFactory.CamSDKCreator，至于是哪个相机我交给了工厂，实现了解耦）
ICamSDK camSDK2 = SimpleFactory.CamSDKCreator();
camSDK2.Start();
camSDK2.Close();
Console.ReadLine();
}
}
}
修改配置，即可改变程序（好处）
不用还要改代码new
ICamSDK camSDK = new HikCamSDK();
camSDK.Start();
camSDK.Close();
Console.ReadLine();
简单工厂模式的优点
- 解耦：客户端不直接依赖具体类，只依赖工厂和接口。
- 集中管理：所有创建逻辑在工厂里，修改方便。
- 扩展性：新增产品时，只需修改工厂（符合开闭原则的部分实现）。
总结
简单工厂模式就像“点餐系统”：
- 你（客户端）说“我要A”。
- 系统（工厂）根据规则返回对应的对象（产品）。
- 你不用关心对象是怎么创建的，只管用就行！
适合简单场景，但复杂项目建议用工厂方法或抽象工厂。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
