面向接口编程
什么是高内聚、低耦合
引自博客园中一篇文章来解释一下:http://www.cnblogs.com/robnetcn/archive/2012/04/15/2449008.html
起因:模块独立性指每个模块只完成系统要求的独立子功能,并且与其他模块的联系最少且接口简单,两个定性的度量标准――耦合性和内聚性。
耦合性也称块间联系:指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密,其耦合性就越强,模块的独立性则越差。模块间耦合高低取决于模块间接口的复杂性、调用的方式及传递的信息。
耦合性分类(低――高): 无直接耦合;数据耦合;标记耦合;控制耦合;公共耦合;内容耦合;
1 无直接耦合:
2 数据耦合: 指两个模块之间有调用关系,传递的是简单的数据值,相当于高级语言的值传递;
3 标记耦合: 指两个模块之间传递的是数据结构,如高级语言中的数组名、记录名、文件名等这些名字即标记,其实传递的是这个数据结构的地址;
4 控制耦合: 指一个模块调用另一个模块时,传递的是控制变量(如开关、标志等),被调模块通过该控制变量的值有选择地执行块内某一功能;
5 公共耦合: 指通过一个公共数据环境相互作用的那些模块间的耦合。公共耦合的复杂程序随耦合模块的个数增加而增加。
6 内容耦合: 这是最高程度的耦合,也是最差的耦合。当一个模块直接使用另一个模块的内部数据,或通过非正常入口而转入另一个模块内部。
内聚性又称块内联系: 指模块的功能强度的度量,即一个模块内部各个元素彼此结合的紧密程度的度量。若一个模块内各元素(语名之间、程序段之间)联系的越紧密,则它的内聚性就越高。
内聚性匪类(低――高): 偶然内聚;逻辑内聚;时间内聚;通信内聚;顺序内聚;功能内聚;
1 偶然内聚: 指一个模块内的各处理元素之间没有任何联系。
2 逻辑内聚: 指模块内执行几个逻辑上相似的功能,通过参数确定该模块完成哪一个功能。
3 时间内聚: 把需要同时执行的动作组合在一起形成的模块为时间内聚模块。
4 通信内聚: 指模块内所有处理元素都在同一个数据结构上操作(有时称之为信息内聚),或者指各处理使用相同的输入数据或者产生相同的输出数据。
5 顺序内聚: 指一个模块中各个处理元素都密切相关于同一功能且必须顺序执行,前一功能元素输出就是下一功能元素的输入。
6 功能内聚: 这是最强的内聚,指模块内所有元素共同完成一个功能,缺一不可。与其他模块的耦合是最弱的。
耦合性与内聚性是模块独立性的两个定性标准,将软件系统划分模块时,尽量做到高内聚低耦合,提高模块的独立性,为设计高质量的软件结构奠定基础。
有个例子很容易明白:一个程序有50个函数,这个程序执行得非常好;然而一旦你修改其中一个函数,其他49个函数都需要做修改,这就是高耦合的后果。
一旦你理解了它,你编写概要设计的时候设计类或者模块自然会考虑到“高内聚,低耦合”。
下面的内容引用:http://www.cnblogs.com/xiaozhi_5638/p/3613176.html
依赖倒置
该原则主要是为了降低模块与模块之间的“耦合度”,提倡模块与模块之间不要发生直接的依赖关系高层模块不应该直接依赖于低层模块,高层模块和低层模块应该同时依赖一个抽象层。如果现在有一个类Manager在处理某一任务时,需要记录错误日志,那么我们可以这样编写代码:
class Manager
{
//…
FileLogger _logger;
public void DoSomething()
{
try
{
//…do something
}
catch(Exception ex)
{
if(_logger == null)
{
_logger = new FileLogger();
}
_logger.Log(ex.ToString())
}
}
}
class FileLogger
{
public void Log(string errorLog)
{
//…write into log file
}
}
如上代码所示,FileLogger类负责将错误日志保存到文件,Manager类中定义了一个Logger类对象,专门负责记录错误日志,这段代码中的“高层模块”Manager类就直接依赖与“低层模块”FileLogger,如果我们现在需要将错误日志记录通过Email发送给别人,或者发送给别的模块,我们不得不去修改Manager类的代码。
“依赖倒置原则”建议我们,Manager类不应该直接依赖于FIleLogger类,而应该依赖一个抽象层(接口层),所以原来代码应该这样写:
class Manager
{
ILog _logger;
public void DoSomething()
{
try
{
}
catch(Exception ex)
{
if(_logger == null)
{
_logger = new FileLogger();//虽然依赖倒置实现了,但是还是要在这里面创建一个实例。后面的依赖注入解决的就是这个问题。
// _logger = new EmailLogger();
//_logger = new NotifyLogger();
}
_logger.Log(ex.ToString());
}
}
}
interface ILog
{
void Log(string errorLog);
}
class FileLogger:ILog
{
public void Log(string errorLog)
{
//…write into file
}
}
class EmailLogger:ILog
{
public void Log(string errorLog)
{
//…send to others as email
}
}
class NotifyLogger:ILog
{
public void Log(string errorLog)
{
//… notify other modules
}
}
如上代码所示,我们把记录错误日志的逻辑抽象出来一个ILog接口,Manager类不再依赖于任何一个具体的类,而是依赖于ILog接口,同时我们可以根据ILog接口实现各种各样的日志记录类,如FileLogger将日志保存到文件、EmailLogger将日志以邮件形式发送给别人、NotifyLogger将错误信息通知程序中其他模块。这样以来,整个代码的灵活度明显增加了,如果我们需要将日志保存到文件,直接使用FileLogger,如果我们想将日志以邮件形式发送别人,直接使用EmailLogger等等。下图显示依赖倒置发生前后:
依赖注入
上面的Manager类虽然不再直接依赖任何具体的日志记录类型,但是实质上,我们创建记录日志类对象还是在Manager内部(catch中),如果我们想换种方式记录日志,还是得动Manager类的代码,有没有一种方式,能够让我们不需要修改Manager代码就能切换日志的记录方式呢?当然是有的,“依赖注入”就是这一问题的具体解决方法,我们有三种方式去让两个类型发生依赖关系:
(1)构造注入(Constructor Injection)
在我们创建Manager对象的时候,将记录日志的对象作为构造参数传递给新创建的Manager对象,假设Manager有一个带ILog类型参数的构造方法,如:
class Manager
{
ILog _logger;
public Manager(ILog logger)
{
_logger = logger;
}
//…
}
那么,我们在创建Manager对象的时候,这样编写代码:
Manager m = new Manager(new FileLogger());
//Manager m = new Manager(new EmailLogger());
//Manager m = new Manager(new NotifyLogger());
很明显,这种日志记录方式一直不变,对Manager终生有效。
(2)方法注入(Method Injection)
为Manager类中每个需要记录日志的方法增加一个ILog的参数,比如Manager.DoSomething方法重新定义为:
class Manager
{
//…
public void DoSomething(ILog logger)
{
try
{
//…
}
catch(Exception ex)
{
logger.Log(ex.ToString());
}
}
}
那么我们之后在使用Manager的时候,每次调用方法都应该为它提供一个记录日志的对象,如:
Manager m = new Manager();
m.DoSomething(new FileLogger());
m.DoSomething(new EmailLogger());
m.DoSomething(new NotifyLogger());
这种记录日志的方式,只对当前方法有效,每次调用方法都可以不同。
(3)属性注入(Property Injection)
在Manager类中公开一个属性,用来设置日志记录对象,Mananger这样定义:
class Manager
{
private ILog _logger;
public ILog Logger
{
get
{
return _logger;
}
set
{
_logger = value;
}
}
//…
}
之后我们使用Mananger时,可以随时更换它的日志记录方式:
Mananger m = new Manager();
m.Logger = new FileLogger();
m.Logger = new EmailLogger();
m.Logger = new NotifyLogger();
使用这种方式,我们可以随时切换记录日志的方式,它的灵活度介于“构造注入”和“方法注入”之间。
以上三种依赖注入方法可以混合使用,也就是说,你可以为Manager类定义一个带ILog类型的参数,同时也可以定义一个ILog类型的属性,或者为每个方法增加一个ILog类型的参数。
注:
【1】在.NET中,“抽象层”可以不使用接口interface去实现,而是直接使用委托,举一个例子,我们使用FileStream.BeginRead方法时,给它提供的一个AsyncCallback回调参数,其实就是属于“方法注入”的一种。
【2】类型与类型之间不可能完全失去依赖关系,怎样让这种非有不可的依赖关系更微弱,是软件设计的一门高深学问。
ASP.NET MVC中的 依赖注入(DI)
在ASP.NET MVC中进行依赖注入的例子主要就是应用在controller中,因为controller要对model进行加工并将model传递到view中,这时候,就要对model和controller之间进行一个解耦的过程。而解耦的过程主要是用DI注入容器。如Ninject。